feat(controller): Add dependent target lookup

controller/BUILD.bazel

@@ -8,6 +8,7 @@ go_library(
         "errors.go",
         "getchangedtargetgraph.go",
         "getchangedtargets.go",
+        "getdependenttargets.go",
         "gettargetgraph.go",
         "metrics.go",
         "output_filter.go",
@@ -43,6 +44,7 @@ go_test(
         "distance_filter_test.go",
         "getchangedtargets_test.go",
         "getchangedtargets_tgb_test.go",
+        "getdependenttargets_test.go",
         "gettargetgraph_test.go",
         "metrics_test.go",
         "output_filter_test.go",

controller/getdependenttargets.go

@@ -0,0 +1,211 @@
+// Copyright (c) 2026 Uber Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package controller
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"maps"
+	"sort"
+	"time"
+
+	tangoerrors "github.com/uber/tango/core/errors"
+	"github.com/uber/tango/core/storage"
+	"github.com/uber/tango/entity"
+	"github.com/uber/tango/internal/mapper"
+	"github.com/uber/tango/internal/tgb"
+	"github.com/uber/tango/observability/metrics"
+	pb "github.com/uber/tango/tangopb"
+	"go.uber.org/zap"
+)
+
+// GetDependentTargets returns every target that transitively depends on a requested target.
+func (c *controller) GetDependentTargets(request *pb.GetDependentTargetsRequest, stream pb.TangoServiceGetDependentTargetsYARPCServer) (retErr error) {
+	validationErr := validateGetDependentTargetsRequest(request)
+	if validationErr != nil {
+		validationErr = tangoerrors.NewUser(validationErr)
+	}
+	repoCfg, repo, repositoryErr := c.resolveRequestRepository(request.GetBuildDescription().GetRemote(), validationErr)
+	e := c.emitter.Tagged(map[string]string{metrics.TagRepo: repo})
+	op := metrics.Begin(e, opGetDependentTargets, metrics.SlowDurationBuckets)
+	logger := c.logger.WithLazy(zap.String("repository", repo))
+
+	defer func() {
+		op.Complete(retErr)
+		if retErr != nil {
+			logger.Error("GetDependentTargets failed", tangoerrors.Fields(retErr)...)
+			retErr = toWireError(retErr)
+		}
+	}()
+	if repositoryErr != nil {
+		return repositoryErr
+	}
+
+	ctx, cancel := c.linkRequestCtx(stream.Context())
+	defer cancel()
+	start := time.Now()
+
+	build, err := mapper.ProtoToBuildDescription(request.GetBuildDescription())
+	if err != nil {
+		return tangoerrors.NewUser(fmt.Errorf("convert build description: %w", err))
+	}
+
+	graphRequest := entity.GetTargetGraphRequest{
+		Build:       build,
+		BypassCache: request.GetBypassCache(),
+	}
+	reader, err := c.getGraph(ctx, e, graphRequest, repoCfg.RepositoryID)
+	if err != nil {
+		return fmt.Errorf("get graph: %w", err)
+	}
+	if reader == nil {
+		return nil
+	}
+	defer func() { _ = reader.Close() }()
+
+	var labels []string
+	if graph, ok := reader.(*storage.TGBGraphReader); ok {
+		labels, err = tgb.DependentLabels(ctx, graph.TGB(), request.GetTargets())
+	} else {
+		labels, err = dependentLabels(ctx, reader, request.GetTargets())
+	}
+	if err != nil {
+		return err
+	}
+
+	if err := sendDependentTargets(stream, labels, c.maxMessageBytes); err != nil {
+		return fmt.Errorf("send response: %w", err)
+	}
+	logger.Info("GetDependentTargets: Successfully processed request",
+		zap.Int("target_count", len(labels)),
+		zap.Duration("total_duration", time.Since(start)),
+	)
+	return nil
+}
+
+func validateGetDependentTargetsRequest(request *pb.GetDependentTargetsRequest) error {
+	if request == nil {
+		return errors.New("request is required")
+	}
+	build := request.GetBuildDescription()
+	if build == nil {
+		return errors.New("build description is required")
+	}
+	if build.GetRemote() == "" {
+		return errors.New("build description remote is required")
+	}
+	if build.GetBaseSha() == "" {
+		return errors.New("build description base_sha is required")
+	}
+	if len(request.GetTargets()) == 0 {
+		return errors.New("at least one target is required")
+	}
+	for i, target := range request.GetTargets() {
+		if target == "" {
+			return fmt.Errorf("targets[%d] is required", i)
+		}
+	}
+	return nil
+}
+
+func dependentLabels(ctx context.Context, reader storage.GraphReader, requested []string) ([]string, error) {
+	targets := make(map[int32][]int32)
+	labels := make(map[int32]string)
+
+	for {
+		chunk, err := reader.Read()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return nil, err
+		}
+		for _, target := range chunk.Targets {
+			targets[target.ID] = target.DirectDependencies
+		}
+		if chunk.Metadata != nil {
+			maps.Copy(labels, chunk.Metadata.TargetIDMapping)
+		}
+	}
+
+	byLabel := make(map[string]int32, len(labels))
+	reverse := make(map[int32][]int32)
+
+	for id, dependencies := range targets {
+		label := labels[id]
+		if label == "" {
+			return nil, fmt.Errorf("target ID %d has no label mapping", id)
+		}
+		byLabel[label] = id
+		for _, dependency := range dependencies {
+			reverse[dependency] = append(reverse[dependency], id)
+		}
+	}
+
+	queue := make([]int32, 0, len(requested))
+	seen := make(map[int32]struct{}, len(requested))
+
+	for _, label := range requested {
+		id, ok := byLabel[label]
+		if !ok {
+			return nil, fmt.Errorf("target %q is absent from target graph", label)
+		}
+		if _, ok := seen[id]; !ok {
+			seen[id] = struct{}{}
+			queue = append(queue, id)
+		}
+	}
+
+	for head := 0; head < len(queue); head++ {
+		if head%cancelCheckInterval == 0 {
+			if err := ctx.Err(); err != nil {
+				return nil, context.Cause(ctx)
+			}
+		}
+		for _, dependent := range reverse[queue[head]] {
+			if _, ok := seen[dependent]; !ok {
+				seen[dependent] = struct{}{}
+				queue = append(queue, dependent)
+			}
+		}
+	}
+
+	result := make([]string, 0, len(queue))
+	for _, id := range queue {
+		result = append(result, labels[id])
+	}
+	sort.Strings(result)
+	return result, nil
+}
+
+func sendDependentTargets(stream pb.TangoServiceGetDependentTargetsYARPCServer, labels []string, maxBytes int) error {
+	response := &pb.GetDependentTargetsResponse{}
+
+	for _, label := range labels {
+		response.Targets = append(response.Targets, label)
+		if response.Size() > maxBytes && len(response.Targets) > 1 {
+			last := response.Targets[len(response.Targets)-1]
+			response.Targets = response.Targets[:len(response.Targets)-1]
+			if err := stream.Send(response); err != nil {
+				return err
+			}
+			response = &pb.GetDependentTargetsResponse{Targets: []string{last}}
+		}
+	}
+
+	return stream.Send(response)
+}

controller/getdependenttargets_test.go

@@ -0,0 +1,136 @@
+// Copyright (c) 2026 Uber Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package controller
+
+import (
+	"bytes"
+	"context"
+	"encoding/gob"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/uber/tango/core/storage"
+	storagemock "github.com/uber/tango/core/storage/storagemock"
+	"github.com/uber/tango/entity"
+	pb "github.com/uber/tango/tangopb"
+	tangomock "github.com/uber/tango/tangopb/tangopbmock"
+	"go.uber.org/mock/gomock"
+	"go.uber.org/zap/zaptest"
+)
+
+func TestGetDependentTargets(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	stream := tangomock.NewMockTangoServiceGetDependentTargetsYARPCServer(ctrl)
+	stream.EXPECT().Context().Return(context.Background())
+	stream.EXPECT().Send(&pb.GetDependentTargetsResponse{Targets: []string{
+		"//app:binary",
+		"//lib:library",
+		"//service:binary",
+	}}).Return(nil)
+
+	var graph bytes.Buffer
+	encoder := gob.NewEncoder(&graph)
+	require.NoError(t, encoder.Encode(entity.GetTargetGraphResponse{Targets: []entity.OptimizedTarget{
+		{ID: 1},
+		{ID: 2, DirectDependencies: []int32{1}},
+		{ID: 3, DirectDependencies: []int32{2}},
+	}}))
+	require.NoError(t, encoder.Encode(entity.GetTargetGraphResponse{Metadata: &entity.Metadata{TargetIDMapping: map[int32]string{
+		1: "//lib:library",
+		2: "//service:binary",
+		3: "//app:binary",
+	}}}))
+
+	store := storagemock.NewMockStorage(ctrl)
+	gomock.InOrder(
+		store.EXPECT().Get(gomock.Any(), gomock.Any()).
+			Return(storage.DownloadResponse{ReadCloser: newMockReadCloser([]byte("treehash"))}, nil),
+		store.EXPECT().Get(gomock.Any(), gomock.Any()).
+			Return(storage.DownloadResponse{ReadCloser: newMockReadCloser(graph.Bytes())}, nil),
+	)
+	c := NewController(context.Background(), Params{
+		RepoConfig: allowAnyRepositoryConfigProvider{},
+		Logger:     zaptest.NewLogger(t),
+		Storage:    store,
+	})
+
+	err := c.GetDependentTargets(&pb.GetDependentTargetsRequest{
+		BuildDescription: &pb.BuildDescription{
+			Strategy: pb.COMPUTATION_STRATEGY_UNSET,
+			Remote:   "repo:go-code",
+			BaseSha:  "sha",
+		},
+		Targets: []string{"//lib:library"},
+	}, stream)
+	require.NoError(t, err)
+}
+
+func TestValidateGetDependentTargetsRequest(t *testing.T) {
+	assert.Error(t, validateGetDependentTargetsRequest(nil))
+	assert.Error(t, validateGetDependentTargetsRequest(&pb.GetDependentTargetsRequest{}))
+	assert.Error(t, validateGetDependentTargetsRequest(&pb.GetDependentTargetsRequest{
+		BuildDescription: &pb.BuildDescription{Strategy: pb.COMPUTATION_STRATEGY_UNSET, Remote: "repo:go-code", BaseSha: "sha"},
+	}))
+	assert.Error(t, validateGetDependentTargetsRequest(&pb.GetDependentTargetsRequest{
+		BuildDescription: &pb.BuildDescription{Strategy: pb.COMPUTATION_STRATEGY_UNSET, Remote: "repo:go-code", BaseSha: "sha"},
+		Targets:          []string{""},
+	}))
+	assert.NoError(t, validateGetDependentTargetsRequest(&pb.GetDependentTargetsRequest{
+		BuildDescription: &pb.BuildDescription{Strategy: pb.COMPUTATION_STRATEGY_UNSET, Remote: "repo:go-code", BaseSha: "sha"},
+		Targets:          []string{"//lib:library"},
+	}))
+}
+
+func TestSendDependentTargetsSplitsResponses(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	stream := tangomock.NewMockTangoServiceGetDependentTargetsYARPCServer(ctrl)
+	first := "//lib:first"
+	second := "//lib:second"
+	stream.EXPECT().Send(&pb.GetDependentTargetsResponse{Targets: []string{first}}).Return(nil)
+	stream.EXPECT().Send(&pb.GetDependentTargetsResponse{Targets: []string{second}}).Return(nil)
+
+	maxBytes := (&pb.GetDependentTargetsResponse{Targets: []string{first}}).Size()
+	require.NoError(t, sendDependentTargets(stream, []string{first, second}, maxBytes))
+}
+
+func TestDependentLabels(t *testing.T) {
+	reader := newGraphReader(t,
+		entity.GetTargetGraphResponse{Targets: []entity.OptimizedTarget{
+			{ID: 1},
+			{ID: 2, DirectDependencies: []int32{1}},
+			{ID: 3, DirectDependencies: []int32{2}},
+		}},
+		entity.GetTargetGraphResponse{Metadata: &entity.Metadata{TargetIDMapping: map[int32]string{
+			1: "//lib:library",
+			2: "//service:binary",
+			3: "//app:binary",
+		}}},
+	)
+
+	labels, err := dependentLabels(context.Background(), reader, []string{"//lib:library"})
+	require.NoError(t, err)
+	assert.Equal(t, []string{"//app:binary", "//lib:library", "//service:binary"}, labels)
+}
+
+func TestDependentLabelsRejectsMissingTarget(t *testing.T) {
+	reader := newGraphReader(t,
+		entity.GetTargetGraphResponse{Targets: []entity.OptimizedTarget{{ID: 1}}},
+		entity.GetTargetGraphResponse{Metadata: &entity.Metadata{TargetIDMapping: map[int32]string{1: "//lib:library"}}},
+	)
+
+	_, err := dependentLabels(context.Background(), reader, []string{"//missing:target"})
+	require.Error(t, err)
+}

controller/metrics.go

@@ -18,5 +18,6 @@ package controller
 const (
 	opGetTargetGraph        = "get_target_graph"
 	opGetChangedTargets     = "get_changed_targets"
+	opGetDependentTargets   = "get_dependent_targets"
 	opGetChangedTargetGraph = "get_changed_target_graph"
 )

internal/tgb/BUILD.bazel

@@ -3,6 +3,7 @@ load("@rules_go//go:def.bzl", "go_library", "go_test")
 go_library(
     name = "tgb",
     srcs = [
+        "dependents.go",
         "dict.go",
         "encode.go",
         "format.go",
@@ -23,6 +24,7 @@ go_library(
 go_test(
     name = "tgb_test",
     srcs = [
+        "dependents_test.go",
         "fuzz_test.go",
         "hashwidth_test.go",
         "sentinel_test.go",