fix: rebuild updates for new packages

Author: tae2089

internal/app/ingest/workflow/indexer_test.go

@@ -422,6 +422,26 @@ type recordingSyncCall struct {
 	existingFiles []string
 }
 
+type countingIncrementalSyncer struct {
+	delegate *incremental.Syncer
+	calls    int
+}
+
+func (s *countingIncrementalSyncer) SyncWithExisting(ctx context.Context, files map[string]ingest.FileInfo, existingFiles []string) (*ingest.SyncStats, error) {
+	s.calls++
+	return s.delegate.SyncWithExisting(ctx, files, existingFiles)
+}
+
+func (s *countingIncrementalSyncer) SyncWithExistingStore(ctx context.Context, graphStore ingest.GraphStore, files map[string]ingest.FileInfo, existingFiles []string) (*ingest.SyncStats, error) {
+	s.calls++
+	return s.delegate.SyncWithExistingStore(ctx, graphStore, files, existingFiles)
+}
+
+func (s *countingIncrementalSyncer) SyncBatchesWithExistingStore(ctx context.Context, graphStore ingest.GraphStore, source ingest.FileBatchSource, deletedFiles []string) (*ingest.SyncStats, error) {
+	s.calls++
+	return s.delegate.SyncBatchesWithExistingStore(ctx, graphStore, source, deletedFiles)
+}
+
 func (r *recordingIncrementalSyncer) Sync(ctx context.Context, files map[string]incremental.FileInfo) (*incremental.SyncStats, error) {
 	panic("unexpected Sync call")
 }
@@ -1121,14 +1141,18 @@ func TestUpdate_ReconcilesExistingCallerAfterTargetFileAdded(t *testing.T) {
 	}
 	writeFile("target.go", "package sample\n\nfunc Target() {}\n")
 
-	syncer := incremental.NewWithRegistry(st, map[string]incremental.Parser{".go": walker}, incremental.WithLogger(slog.Default()))
+	delegate := incremental.NewWithRegistry(st, map[string]incremental.Parser{".go": walker}, incremental.WithLogger(slog.Default()))
+	syncer := &countingIncrementalSyncer{delegate: delegate}
 	stats, err := svc.Update(ctx, UpdateOptions{BuildOptions: BuildOptions{Dir: tmpDir}, Syncer: syncer})
 	if err != nil {
 		t.Fatalf("Update after target add: %v", err)
 	}
 	if stats.Added != 1 {
 		t.Fatalf("Added = %d, want one newly added target", stats.Added)
 	}
+	if syncer.calls != 1 {
+		t.Fatalf("incremental sync calls = %d, want existing-package update path", syncer.calls)
+	}
 
 	source, err := st.GetNode(ctx, "sample.Source")
 	if err != nil || source == nil {
@@ -1150,6 +1174,78 @@ func TestUpdate_ReconcilesExistingCallerAfterTargetFileAdded(t *testing.T) {
 	t.Fatalf("expected existing caller edge from %d to newly added target %d, got %+v", source.ID, target.ID, edges)
 }
 
+func TestUpdate_ReconcilesExistingCrossPackageCallerAfterTargetPackageAdded(t *testing.T) {
+	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{Logger: gormlogger.Discard})
+	if err != nil {
+		t.Fatalf("open db: %v", err)
+	}
+	st := graphgorm.New(db)
+	if err := st.AutoMigrate(); err != nil {
+		t.Fatalf("migrate: %v", err)
+	}
+	walker := treesitter.NewWalker(treesitter.GoSpec)
+	svc := &Service{Store: st, UnitOfWork: newTestUnitOfWork(db, nil), Walkers: map[string]Parser{".go": walker}, Logger: slog.Default()}
+
+	tmpDir := t.TempDir()
+	writeFile := func(rel, content string) {
+		full := filepath.Join(tmpDir, rel)
+		if err := os.MkdirAll(filepath.Dir(full), 0o755); err != nil {
+			t.Fatalf("mkdir %s: %v", rel, err)
+		}
+		if err := os.WriteFile(full, []byte(content), 0o644); err != nil {
+			t.Fatalf("write %s: %v", rel, err)
+		}
+	}
+	writeFile("go.mod", "module github.com/example/project\n\ngo 1.25.0\n")
+	writeFile("app/source.go", `package app
+
+import "github.com/example/project/api"
+
+func Source() { api.Target() }
+`)
+
+	ctx := context.Background()
+	if _, err := svc.Build(ctx, BuildOptions{Dir: tmpDir}); err != nil {
+		t.Fatalf("Build before target package exists: %v", err)
+	}
+	writeFile("api/target.go", "package api\n\nfunc Target() {}\n")
+
+	delegate := incremental.NewWithRegistry(st, map[string]incremental.Parser{".go": walker}, incremental.WithLogger(slog.Default()))
+	syncer := &countingIncrementalSyncer{delegate: delegate}
+	stats, err := svc.Update(ctx, UpdateOptions{BuildOptions: BuildOptions{Dir: tmpDir}, Syncer: syncer})
+	if err != nil {
+		t.Fatalf("Update after target package add: %v", err)
+	}
+	if stats.Added != 1 {
+		t.Fatalf("Added = %d, want one newly added target file", stats.Added)
+	}
+	if stats.Modified != 0 || stats.Skipped != 1 || stats.Deleted != 0 {
+		t.Fatalf("fallback change counts = %+v, want added=1 modified=0 skipped=1 deleted=0", stats)
+	}
+	if syncer.calls != 0 {
+		t.Fatalf("incremental sync calls = %d, want full-build fallback", syncer.calls)
+	}
+
+	source, err := st.GetNode(ctx, "app.Source")
+	if err != nil || source == nil {
+		t.Fatalf("GetNode source: node=%v err=%v", source, err)
+	}
+	target, err := st.GetNode(ctx, "api.Target")
+	if err != nil || target == nil {
+		t.Fatalf("GetNode target: node=%v err=%v", target, err)
+	}
+	edges, err := st.GetEdgesFrom(ctx, source.ID)
+	if err != nil {
+		t.Fatalf("GetEdgesFrom: %v", err)
+	}
+	for _, edge := range edges {
+		if edge.Kind == graph.EdgeKindCalls && edge.ToNodeID == target.ID {
+			return
+		}
+	}
+	t.Fatalf("expected cross-package caller edge from %d to newly added target %d, got %+v", source.ID, target.ID, edges)
+}
+
 func TestUpdate_RemovesStaleCrossFileGoStructuralImplements(t *testing.T) {
 	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{Logger: gormlogger.Discard})
 	if err != nil {
@@ -3393,6 +3489,15 @@ func TestUpdate_IncludePaths_FiltersExistingFilesWhenReplaceFalse(t *testing.T)
 	if got, want := deleteCall.existingFiles, []string{filepath.Join("src", "api", "handler.go")}; !reflect.DeepEqual(got, want) {
 		t.Fatalf("delete pass existingFiles mismatch: got=%v want=%v (helper.go outside include path must be scoped out)", got, want)
 	}
+	var outsideCount int64
+	if err := db.Model(&graph.Node{}).
+		Where("namespace = ? AND file_path = ?", requestctx.DefaultNamespace, filepath.Join("src", "other", "helper.go")).
+		Count(&outsideCount).Error; err != nil {
+		t.Fatalf("count out-of-scope node: %v", err)
+	}
+	if outsideCount != 1 {
+		t.Fatalf("out-of-scope node count = %d, want preserved graph state", outsideCount)
+	}
 }
 
 func TestUpdate_ExcludePatterns_LeavesMatchingFilesOutOfSync(t *testing.T) {

internal/app/ingest/workflow/packages.go

@@ -504,13 +504,13 @@ func affectedPackageImportPaths(packages map[string]languagePackageInfo, affecte
 	return affected
 }
 
-// addUnchangedPeersForAddedFiles marks unchanged persisted peers for reparse when a new file joins their package or directory.
-// @intent let local symbol lookup observe declarations introduced by newly added source files during incremental update.
-// @domainRule discovered packages cover multi-directory language packages; a same-directory fallback preserves local resolution when discovery is unavailable.
+// addUnchangedPeersForAddedFiles marks local unchanged peers and reports whether added files require graph-wide reconciliation.
+// @intent let existing-package additions stay incremental while signaling new package/directory additions that can affect unresolved external callers.
+// @domainRule additions to existing packages reparse package/directory peers; a wholly new package or source directory requires full-graph reconciliation because unresolved external callers are not persisted.
 // @mutates forceFiles
-func addUnchangedPeersForAddedFiles(forceFiles map[string]struct{}, packages map[string]languagePackageInfo, existingNodesByFile map[string][]graph.Node, currentHashes map[string]string) {
-	if forceFiles == nil || len(existingNodesByFile) == 0 || len(currentHashes) == 0 {
-		return
+func addUnchangedPeersForAddedFiles(forceFiles map[string]struct{}, packages map[string]languagePackageInfo, existingNodesByFile map[string][]graph.Node, currentHashes map[string]string) bool {
+	if forceFiles == nil || len(currentHashes) == 0 {
+		return false
 	}
 	addedFiles := make([]string, 0)
 	addedDirs := make(map[string]struct{})
@@ -521,20 +521,36 @@ func addUnchangedPeersForAddedFiles(forceFiles map[string]struct{}, packages map
 		}
 	}
 	if len(addedFiles) == 0 {
-		return
+		return false
 	}
 	peerFiles := make(map[string]struct{})
+	wideReparse := false
 	for _, importPath := range affectedPackageImportPaths(packages, addedFiles) {
-		for _, filePath := range packages[importPath].Files {
+		pkg := packages[importPath]
+		hasPersistedMember := false
+		for _, filePath := range pkg.Files {
+			if len(existingNodesByFile[filepath.ToSlash(filePath)]) > 0 {
+				hasPersistedMember = true
+			}
 			peerFiles[filepath.ToSlash(filePath)] = struct{}{}
 		}
+		if !hasPersistedMember {
+			wideReparse = true
+		}
 	}
+	existingDirs := make(map[string]struct{})
 	for filePath := range existingNodesByFile {
 		filePath = filepath.ToSlash(filePath)
+		existingDirs[path.Dir(filePath)] = struct{}{}
 		if _, sameDir := addedDirs[path.Dir(filePath)]; sameDir {
 			peerFiles[filePath] = struct{}{}
 		}
 	}
+	for dir := range addedDirs {
+		if _, existed := existingDirs[dir]; !existed {
+			wideReparse = true
+		}
+	}
 	for filePath := range peerFiles {
 		nodes := existingNodesByFile[filePath]
 		currentHash, present := currentHashes[filePath]
@@ -543,6 +559,20 @@ func addUnchangedPeersForAddedFiles(forceFiles map[string]struct{}, packages map
 		}
 		forceFiles[filePath] = struct{}{}
 	}
+	return wideReparse
+}
+
+// addAllUnchangedFiles expands a conservative incremental fallback to every unchanged file in the current scope.
+// @intent preserve graph correctness when full-build fallback is unsafe or unavailable.
+// @mutates forceFiles
+func addAllUnchangedFiles(forceFiles map[string]struct{}, existingNodesByFile map[string][]graph.Node, currentHashes map[string]string) {
+	for filePath, nodes := range existingNodesByFile {
+		currentHash, present := currentHashes[filePath]
+		if len(nodes) == 0 || !present || nodes[0].Hash != currentHash {
+			continue
+		}
+		forceFiles[filepath.ToSlash(filePath)] = struct{}{}
+	}
 }
 
 // appendUniqueString appends a string to a slice only if it is not already present.