Improve import package resolution

Author: tae2089

internal/analysis/impact/impact.go

@@ -72,7 +72,7 @@ func (a *Analyzer) ImpactRadius(ctx context.Context, nodeID uint, depth int) ([]
 // @param opts traversal limits applied during BFS
 // @return RadiusResult with visited nodes and truncation metadata
 // @domainRule traverses outgoing and incoming edges in lock step at each depth
-// @ensures Truncated is true when MaxNodes stopped traversal or post-trim
+// @ensures Truncated is true when MaxNodes stopped traversal before adding another node
 func (a *Analyzer) ImpactRadiusBounded(ctx context.Context, nodeID uint, depth int, opts RadiusOptions) (*RadiusResult, error) {
 	if opts.MaxDepth > 0 && depth > opts.MaxDepth {
 		depth = opts.MaxDepth

internal/analysis/incremental/incremental.go

@@ -231,6 +231,7 @@ func (s *Syncer) syncWithExisting(ctx context.Context, syncStore Store, files ma
 			if err != nil {
 				return nil, err
 			}
+			resolved = edgeresolve.FilterResolved(resolved)
 			if err := syncStore.UpsertEdges(ctx, resolved); err != nil {
 				return nil, err
 			}

internal/analysis/incremental/incremental_test.go

@@ -500,6 +500,40 @@ func TestSyncWithExisting_ReleasesContentAfterProcessing(t *testing.T) {
 	}
 }
 
+func TestSyncWithExisting_DoesNotPersistUnresolvedEdges(t *testing.T) {
+	st := newStore()
+	parser := &staticParser{result: map[string]parseResult{
+		"main.go": {
+			nodes: []model.Node{{
+				QualifiedName: "pkg.Main",
+				Kind:          model.NodeKindFunction,
+				Name:          "Main",
+				FilePath:      "main.go",
+				StartLine:     1,
+				EndLine:       3,
+				Hash:          "hash",
+				Language:      "go",
+			}},
+			edges: []model.Edge{{
+				Kind:        model.EdgeKindCalls,
+				FilePath:    "main.go",
+				Line:        2,
+				Fingerprint: "calls:main.go:pkg.Missing:2",
+			}},
+		},
+	}}
+	syncer := New(st, parser)
+	_, err := syncer.Sync(context.Background(), map[string]FileInfo{
+		"main.go": {Hash: "hash", Content: []byte("package pkg\nfunc Main(){ Missing() }")},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(st.upsertedEdges) != 0 {
+		t.Fatalf("expected unresolved edge to be skipped, got %+v", st.upsertedEdges)
+	}
+}
+
 func TestSyncWithExisting_ReleasesContentForUnchangedAndUnparsedFiles(t *testing.T) {
 	st := newStore()
 	st.nodes["pkg.Existing"] = &model.Node{QualifiedName: "pkg.Existing", Kind: model.NodeKindFunction, Name: "Existing", FilePath: "exist.go", Hash: "same123", Language: "go"}

internal/edgeresolve/resolve.go

@@ -99,6 +99,22 @@ func Resolve(ctx context.Context, lookup NodeLookup, edges []model.Edge) ([]mode
 	return out, nil
 }
 
+// FilterResolved returns only edges that have both persisted endpoints.
+// @intent prevent unresolved syntax candidates from occupying fingerprints before they become traversable
+func FilterResolved(edges []model.Edge) []model.Edge {
+	if len(edges) == 0 {
+		return nil
+	}
+	out := make([]model.Edge, 0, len(edges))
+	for _, edge := range edges {
+		if edge.FromNodeID == 0 || edge.ToNodeID == 0 {
+			continue
+		}
+		out = append(out, edge)
+	}
+	return out
+}
+
 func edgeFiles(edges []model.Edge) []string {
 	seen := make(map[string]bool)
 	var files []string
@@ -313,6 +329,11 @@ func resolveImportsFrom(ctx context.Context, lookup NodeLookup, edge *model.Edge
 	if !ok {
 		return
 	}
+	if target := uniquePackageNode(st.qnIndex[importPath]); target != nil {
+		edge.ToNodeID = target.ID
+		st.loadImportFileNodes(ctx, lookup, importPath)
+		return
+	}
 	if target := uniqueFileNode(st.qnIndex[importPath]); target != nil {
 		edge.ToNodeID = target.ID
 		st.loadFileNodes(ctx, lookup, target.FilePath)
@@ -324,6 +345,20 @@ func resolveImportsFrom(ctx context.Context, lookup NodeLookup, edge *model.Edge
 	}
 }
 
+func (st *resolveState) loadImportFileNodes(ctx context.Context, lookup NodeLookup, importPath string) {
+	prefixLookup, ok := lookup.(filePrefixLookup)
+	if !ok || importPath == "" {
+		return
+	}
+	nodes, err := prefixLookup.GetFileNodesByPathSuffix(ctx, importPath)
+	if err != nil {
+		return
+	}
+	for _, node := range uniqueFileNodes(nodes) {
+		st.loadFileNodes(ctx, lookup, node.FilePath)
+	}
+}
+
 func (st *resolveState) loadFileNodes(ctx context.Context, lookup NodeLookup, filePath string) {
 	if filePath == "" {
 		return
@@ -408,6 +443,27 @@ func representativeImportFile(nodes []model.Node) *model.Node {
 	return &files[0]
 }
 
+func uniquePackageNode(nodes []model.Node) *model.Node {
+	var found *model.Node
+	seen := make(map[uint]bool)
+	for i := range nodes {
+		if nodes[i].Kind != model.NodeKindPackage {
+			continue
+		}
+		if nodes[i].ID != 0 && seen[nodes[i].ID] {
+			continue
+		}
+		if nodes[i].ID != 0 {
+			seen[nodes[i].ID] = true
+		}
+		if found != nil {
+			return nil
+		}
+		found = &nodes[i]
+	}
+	return found
+}
+
 func uniqueFileNodes(nodes []model.Node) []model.Node {
 	seen := make(map[uint]bool)
 	var files []model.Node
@@ -458,19 +514,23 @@ func resolveInherits(edge *model.Edge, st *resolveState) {
 }
 
 func resolveTestedBy(edge *model.Edge, st *resolveState) {
-	bare, testQN, ok := testedByEndpoints(*edge)
+	callee, testQN, ok := testedByEndpoints(*edge)
 	if !ok {
 		return
 	}
 	if from := uniqueCallable(st.qnIndex[testQN]); from != nil {
 		edge.FromNodeID = from.ID
 	}
-	if to := resolveProductionFunction(st, edge.FilePath, bare); to != nil {
+	if to := resolveProductionFunction(st, edge.FilePath, callee); to != nil {
 		edge.ToNodeID = to.ID
 	}
 }
 
-func resolveProductionFunction(st *resolveState, testFilePath, bare string) *model.Node {
+func resolveProductionFunction(st *resolveState, testFilePath, callee string) *model.Node {
+	if target := uniqueCallable(st.qnIndex[callee]); target != nil {
+		return target
+	}
+	bare := lastSegment(callee)
 	pkg := packageForFile(st.nodesByFile[testFilePath])
 	if pkg != "" {
 		if target := uniqueCallable(st.qnIndex[pkg+"."+bare]); target != nil {

internal/edgeresolve/resolve_test.go

@@ -331,6 +331,27 @@ func TestResolveImportsFromBindsLexicographicRepresentativeForMultiFilePackage(t
 	}
 }
 
+func TestResolveImportsFromPrefersPackageNodeOverFileRepresentative(t *testing.T) {
+	lookup := fakeLookup{nodes: []model.Node{
+		{ID: 10, QualifiedName: "cmd/main.go", Name: "cmd/main.go", Kind: model.NodeKindFile, FilePath: "cmd/main.go", Language: "go"},
+		{ID: 20, QualifiedName: "internal/mcp/a.go", Name: "internal/mcp/a.go", Kind: model.NodeKindFile, FilePath: "internal/mcp/a.go", Language: "go"},
+		{ID: 21, QualifiedName: "internal/mcp/z.go", Name: "internal/mcp/z.go", Kind: model.NodeKindFile, FilePath: "internal/mcp/z.go", Language: "go"},
+		{ID: 30, QualifiedName: "github.com/example/project/internal/mcp", Name: "mcp", Kind: model.NodeKindPackage, FilePath: "internal/mcp", Language: "go"},
+	}}
+	edges, err := Resolve(context.Background(), lookup, []model.Edge{{
+		Kind:        model.EdgeKindImportsFrom,
+		FilePath:    "cmd/main.go",
+		Line:        2,
+		Fingerprint: "imports_from:cmd/main.go:github.com/example/project/internal/mcp:2",
+	}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := edges[0].ToNodeID; got != 30 {
+		t.Fatalf("ToNodeID=%d, want package node 30", got)
+	}
+}
+
 func TestResolveImportsFromLeavesAmbiguousSuffixUnresolved(t *testing.T) {
 	lookup := fakeLookup{nodes: []model.Node{
 		{ID: 10, QualifiedName: "cmd/main.go", Name: "cmd/main.go", Kind: model.NodeKindFile, FilePath: "cmd/main.go", Language: "go"},
@@ -395,6 +416,42 @@ func TestResolveTestedByBindsTestAndProductionEndpoints(t *testing.T) {
 	}
 }
 
+func TestFilterResolvedDropsEdgesWithMissingEndpoints(t *testing.T) {
+	edges := FilterResolved([]model.Edge{
+		{FromNodeID: 1, ToNodeID: 2, Kind: model.EdgeKindCalls, Fingerprint: "resolved"},
+		{FromNodeID: 0, ToNodeID: 2, Kind: model.EdgeKindCalls, Fingerprint: "missing-from"},
+		{FromNodeID: 1, ToNodeID: 0, Kind: model.EdgeKindCalls, Fingerprint: "missing-to"},
+	})
+	if len(edges) != 1 {
+		t.Fatalf("expected 1 resolved edge, got %d: %+v", len(edges), edges)
+	}
+	if edges[0].Fingerprint != "resolved" {
+		t.Fatalf("expected resolved edge to remain, got %+v", edges[0])
+	}
+}
+
+func TestResolveTestedByBindsQualifiedProductionEndpoint(t *testing.T) {
+	lookup := fakeLookup{nodes: []model.Node{
+		{ID: 1, QualifiedName: "calc.Add", Name: "Add", Kind: model.NodeKindFunction, FilePath: "add.go", StartLine: 3, EndLine: 5, Language: "go"},
+		{ID: 2, QualifiedName: "calc_test.TestAdd", Name: "TestAdd", Kind: model.NodeKindTest, FilePath: "add_test.go", StartLine: 3, EndLine: 7, Language: "go"},
+	}}
+	edges, err := Resolve(context.Background(), lookup, []model.Edge{{
+		Kind:        model.EdgeKindTestedBy,
+		FilePath:    "add_test.go",
+		Line:        5,
+		Fingerprint: "tested_by:add_test.go:calc.Add:calc_test.TestAdd",
+	}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := edges[0].FromNodeID; got != 2 {
+		t.Fatalf("FromNodeID=%d, want test node 2", got)
+	}
+	if got := edges[0].ToNodeID; got != 1 {
+		t.Fatalf("ToNodeID=%d, want production node 1", got)
+	}
+}
+
 func TestResolveTestedByLeavesAmbiguousProductionUnresolved(t *testing.T) {
 	lookup := fakeLookup{nodes: []model.Node{
 		{ID: 1, QualifiedName: "pkg.Add", Name: "Add", Kind: model.NodeKindFunction, FilePath: "add_test.go", StartLine: 3, EndLine: 5, Language: "go"},

internal/model/node.go

@@ -8,6 +8,7 @@ type NodeKind string
 
 const (
 	NodeKindFile     NodeKind = "file"
+	NodeKindPackage  NodeKind = "package"
 	NodeKindClass    NodeKind = "class"
 	NodeKindFunction NodeKind = "function"
 	NodeKindType     NodeKind = "type"