Drop Bounded* analyzer interfaces and their dead fallback branches

BoundedImpactAnalyzer and BoundedFlowTracer were obtained via runtime
downcast from the base ImpactAnalyzer/FlowTracer, but the sole concrete
types (*impact.Analyzer, *flows.Tracer) and the test mock all implement
the bounded method, so the downcast's ok was always true and the else
fallback branches never executed. Fold the bounded method into the base
interface, call it directly, and delete the two Bounded* interfaces, the
downcasts, the dead else branches, and the now-unused mock method.

No behavior change: the removed branches were unreachable in production.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: tae2089

internal/mcp/deps.go

@@ -33,29 +33,19 @@ type Parser interface {
 	ParseWithContext(ctx context.Context, filePath string, content []byte) ([]model.Node, []model.Edge, error)
 }
 
-// ImpactAnalyzer defines the blast-radius analysis contract for graph nodes.
-// @intent Injects an analyzer that calculates the impact radius of node changes into the server handler.
+// ImpactAnalyzer defines the bounded blast-radius analysis contract for graph nodes.
+// @intent inject a node/depth-capped blast-radius analyzer so a single MCP request cannot
+// expand into an unbounded graph walk.
 // @see mcp.handlers.getImpactRadius
 type ImpactAnalyzer interface {
-	ImpactRadius(ctx context.Context, nodeID uint, depth int) ([]model.Node, error)
-}
-
-// BoundedImpactAnalyzer extends ImpactAnalyzer with node and depth caps to prevent runaway traversal on large graphs.
-// @intent expose bounded blast-radius analysis for handlers that must protect shared MCP requests from unbounded graph walks.
-type BoundedImpactAnalyzer interface {
 	ImpactRadiusBounded(ctx context.Context, nodeID uint, depth int, opts impactpkg.RadiusOptions) (*impactpkg.RadiusResult, error)
 }
 
-// FlowTracer defines the call-flow tracing contract for graph nodes.
-// @intent Connects an analyzer to the server that reconstructs call flows starting from a given node.
+// FlowTracer defines the bounded call-flow tracing contract for graph nodes.
+// @intent inject a node-capped call-flow tracer so a deep call chain cannot expand into an
+// unbounded traversal.
 // @see mcp.handlers.traceFlow
 type FlowTracer interface {
-	TraceFlow(ctx context.Context, startNodeID uint) (*model.Flow, error)
-}
-
-// BoundedFlowTracer extends FlowTracer with a node cap to prevent runaway traversal on deeply nested call chains.
-// @intent let MCP handlers trace deep call chains without letting one request expand into an unbounded traversal.
-type BoundedFlowTracer interface {
 	TraceFlowBounded(ctx context.Context, startNodeID uint, opts flowspkg.TraceOptions) (*flowspkg.TraceResult, error)
 }
 

internal/mcp/handler_analysis.go

@@ -161,32 +161,13 @@ func (h *handlers) getImpactRadius(ctx context.Context, request mcp.CallToolRequ
 			return "", nodeNotFoundErr(qn)
 		}
 
-		var nodes []model.Node
-		truncated := false
-		if bounded, ok := h.deps.ImpactAnalyzer.(BoundedImpactAnalyzer); ok {
-			res, err := bounded.ImpactRadiusBounded(ctx, node.ID, depth, impactpkg.RadiusOptions{MaxDepth: maxDepth, MaxNodes: maxNodes})
-			if err != nil {
-				log.ErrorContext(ctx, "impact analysis error", append(obs.TraceLogArgs(ctx), "node_id", node.ID, trace.SlogError(err))...)
-				return "", trace.Wrap(err, "impact analysis error")
-			}
-			nodes = res.Nodes
-			truncated = res.Truncated
-		} else {
-			if maxDepth > 0 && depth > maxDepth {
-				depth = maxDepth
-				truncated = true
-			}
-			var err error
-			nodes, err = h.deps.ImpactAnalyzer.ImpactRadius(ctx, node.ID, depth)
-			if err != nil {
-				log.ErrorContext(ctx, "impact analysis error", append(obs.TraceLogArgs(ctx), "node_id", node.ID, trace.SlogError(err))...)
-				return "", trace.Wrap(err, "impact analysis error")
-			}
-			if maxNodes > 0 && len(nodes) > maxNodes {
-				nodes = nodes[:maxNodes]
-				truncated = true
-			}
+		res, err := h.deps.ImpactAnalyzer.ImpactRadiusBounded(ctx, node.ID, depth, impactpkg.RadiusOptions{MaxDepth: maxDepth, MaxNodes: maxNodes})
+		if err != nil {
+			log.ErrorContext(ctx, "impact analysis error", append(obs.TraceLogArgs(ctx), "node_id", node.ID, trace.SlogError(err))...)
+			return "", trace.Wrap(err, "impact analysis error")
 		}
+		nodes := res.Nodes
+		truncated := res.Truncated
 
 		log.InfoContext(ctx, "get_impact_radius completed", append(obs.TraceLogArgs(ctx), "qualified_name", qn, "result_count", len(nodes))...)
 
@@ -249,32 +230,15 @@ func (h *handlers) traceFlow(ctx context.Context, request mcp.CallToolRequest) (
 			return "", nodeNotFoundErr(qn)
 		}
 
-		var flow *model.Flow
-		truncated := false
-		containsFallbackCalls := false
-		fallbackEdgesCount := 0
-		if bounded, ok := h.deps.FlowTracer.(BoundedFlowTracer); ok {
-			res, err := bounded.TraceFlowBounded(ctx, node.ID, flowspkg.TraceOptions{MaxNodes: maxNodes, IncludeFallbackCalls: &includeFallbackCalls})
-			if err != nil {
-				log.ErrorContext(ctx, "trace error", append(obs.TraceLogArgs(ctx), "node_id", node.ID, trace.SlogError(err))...)
-				return "", trace.Wrap(err, "trace error")
-			}
-			flow = res.Flow
-			truncated = res.Truncated
-			containsFallbackCalls = res.ContainsFallbackCalls
-			fallbackEdgesCount = res.FallbackEdgesCount
-		} else {
-			var err error
-			flow, err = h.deps.FlowTracer.TraceFlow(ctx, node.ID)
-			if err != nil {
-				log.ErrorContext(ctx, "trace error", append(obs.TraceLogArgs(ctx), "node_id", node.ID, trace.SlogError(err))...)
-				return "", trace.Wrap(err, "trace error")
-			}
-			if maxNodes > 0 && len(flow.Members) > maxNodes {
-				flow.Members = flow.Members[:maxNodes]
-				truncated = true
-			}
+		res, err := h.deps.FlowTracer.TraceFlowBounded(ctx, node.ID, flowspkg.TraceOptions{MaxNodes: maxNodes, IncludeFallbackCalls: &includeFallbackCalls})
+		if err != nil {
+			log.ErrorContext(ctx, "trace error", append(obs.TraceLogArgs(ctx), "node_id", node.ID, trace.SlogError(err))...)
+			return "", trace.Wrap(err, "trace error")
 		}
+		flow := res.Flow
+		truncated := res.Truncated
+		containsFallbackCalls := res.ContainsFallbackCalls
+		fallbackEdgesCount := res.FallbackEdgesCount
 
 		log.InfoContext(ctx, "trace_flow completed", append(obs.TraceLogArgs(ctx), "qualified_name", qn, "members", len(flow.Members))...)
 

internal/mcp/testmocks_test.go

@@ -365,23 +365,6 @@ type mockFlowTracer struct {
 	remainderErr error
 }
 
-func (m *mockFlowTracer) TraceFlow(ctx context.Context, startNodeID uint) (*model.Flow, error) {
-	m.calls++
-	flow := m.returnFlow
-	if flow == nil {
-		flow = &model.Flow{
-			Namespace: ctxns.FromContext(ctx),
-			Name:      "flow_from_mock",
-			Members: []model.FlowMembership{{
-				NodeID:    startNodeID,
-				Ordinal:   0,
-				Namespace: ctxns.FromContext(ctx),
-			}},
-		}
-	}
-	return flow, m.traceErr
-}
-
 func (m *mockFlowTracer) TraceFlowBounded(ctx context.Context, startNodeID uint, opts flows.TraceOptions) (*flows.TraceResult, error) {
 	m.calls++
 	m.opts = append(m.opts, opts)