Fix incremental update: stale callee shards + false HEAD-change on startup (#99)

* Fix two incremental-update correctness bugs

1. watcher.go: trim SHA at startup to avoid false HEAD-change on first poll

   w.lastCommitSHA was set from raw git output (includes trailing newline).
   On the first poll, currentSHA (trimmed) != lastCommitSHA (untrimmed),
   so headChanged was always true. The downstream git-diff call would fail
   silently (invalid ref), but the spurious headChanged = true was wasteful
   and misleading.

2. daemon.go: track old callees so removed calls re-render callee shards

   computeAffectedFiles walked current callers but never tracked pre-merge
   callees. When funcA (in file A) stopped calling funcB (in file B), file B
   was not marked affected, so its shard kept a stale "funcB ← funcA" entry
   until the next full rebuild.

   Fix: snapshot d.cache.Callees for functions in changed files before the
   merge (parallel to the existing oldImports snapshot), pass them as
   oldCalleeFiles to computeAffectedFiles, and mark those files affected.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* Fix lint: combine map params in computeAffectedFiles signature

gocritic paramTypeCombine: two consecutive map[string][]string parameters
can be declared together as "oldImports, oldCalleeFiles map[string][]string".

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: greynewell

internal/shards/daemon.go

@@ -257,19 +257,34 @@ func (d *Daemon) incrementalUpdate(ctx context.Context, changedFiles []string) {
 		return
 	}
 
-	// Snapshot old import relationships before the merge so we can re-render
-	// files that lost an "imported-by" reference after A stops importing B.
+	// Snapshot old import and call relationships before the merge so we can
+	// re-render files that lost a reference after A stops importing/calling B.
 	oldImports := make(map[string][]string, len(changedFiles))
+	oldCalleeFiles := make(map[string][]string) // funcID -> callee file paths
 	func() {
 		d.mu.Lock()
 		defer d.mu.Unlock()
+		changedSet := make(map[string]bool, len(changedFiles))
+		for _, f := range changedFiles {
+			changedSet[f] = true
+		}
 		for _, f := range changedFiles {
 			if deps := d.cache.Imports[f]; len(deps) > 0 {
 				cp := make([]string, len(deps))
 				copy(cp, deps)
 				oldImports[f] = cp
 			}
 		}
+		for id, fn := range d.cache.FnByID {
+			if !changedSet[fn.File] {
+				continue
+			}
+			for _, callee := range d.cache.Callees[id] {
+				if callee.File != "" {
+					oldCalleeFiles[id] = append(oldCalleeFiles[id], callee.File)
+				}
+			}
+		}
 	}()
 
 	var affected []string
@@ -280,7 +295,7 @@ func (d *Daemon) incrementalUpdate(ctx context.Context, changedFiles []string) {
 		d.mergeGraph(ir, changedFiles)
 		d.cache = NewCache()
 		d.cache.Build(d.ir)
-		affected = d.computeAffectedFiles(changedFiles, oldImports)
+		affected = d.computeAffectedFiles(changedFiles, oldImports, oldCalleeFiles)
 		cacheSnapshot = d.cache
 	}()
 
@@ -592,7 +607,10 @@ func (d *Daemon) assignNewFilesToDomains(newNodes []api.Node) {
 // oldImports maps each changed file to the set of files it imported BEFORE
 // the merge, so that files whose "imported-by" sections lost a reference
 // are also re-rendered.
-func (d *Daemon) computeAffectedFiles(changedFiles []string, oldImports map[string][]string) []string {
+// oldCalleeFiles maps each function ID (in a changed file) to the set of files
+// its callees lived in BEFORE the merge, so that callee files whose
+// "← caller" entries were removed are also re-rendered.
+func (d *Daemon) computeAffectedFiles(changedFiles []string, oldImports, oldCalleeFiles map[string][]string) []string {
 	affected := make(map[string]bool)
 
 	for _, f := range changedFiles {
@@ -625,6 +643,12 @@ func (d *Daemon) computeAffectedFiles(changedFiles []string, oldImports map[stri
 					affected[caller.File] = true
 				}
 			}
+			// Files that functions in f used to call (old callees): if the call was
+			// removed, those files' shards still show "funcB ← funcA" and need
+			// re-rendering to drop the stale back-reference.
+			for _, calleeFile := range oldCalleeFiles[id] {
+				affected[calleeFile] = true
+			}
 		}
 	}
 

internal/shards/daemon_test.go

@@ -359,3 +359,83 @@ func TestMergeGraph_DomainsPreservedEvenWhenIncrementalHasMore(t *testing.T) {
 		t.Errorf("expected original domain preserved, got %v", result.Domains)
 	}
 }
+
+// ── computeAffectedFiles tests ───────────────────────────────────────────────
+
+// TestComputeAffectedFiles_OldCalleeIncluded verifies that when a function in a
+// changed file used to call a function in another file, that other file is
+// included in the affected set even if the call was removed by the update.
+//
+// Before the fix, computeAffectedFiles only walked d.cache.Callers (new state)
+// and oldImports. It never consulted pre-merge callee relationships. As a result,
+// if funcA stopped calling funcB, file B was not marked affected and its shard
+// kept the stale "funcB ← funcA" line.
+func TestComputeAffectedFiles_OldCalleeIncluded(t *testing.T) {
+	ir := buildIR(
+		[]api.Node{
+			newNode("file-a", []string{"File"}, "filePath", "a.go"),
+			newNode("fn-a", []string{"Function"}, "filePath", "a.go", "name", "FuncA"),
+			newNode("file-b", []string{"File"}, "filePath", "b.go"),
+			newNode("fn-b", []string{"Function"}, "filePath", "b.go", "name", "FuncB"),
+		},
+		[]api.Relationship{
+			// FuncA calls FuncB (before the incremental update).
+			newRel("calls-1", "calls", "fn-a", "fn-b"),
+		},
+	)
+	d := NewTestDaemon(ir)
+	d.cache = NewCache()
+	d.cache.Build(ir)
+
+	// Simulate pre-merge callees snapshot: fn-a used to call fn-b (in b.go).
+	oldCalleeFiles := map[string][]string{
+		"fn-a": {"b.go"},
+	}
+
+	// After the incremental update, FuncA no longer calls FuncB, so the new
+	// cache has no callee relationship. Only a.go is in changedFiles.
+	affected := d.computeAffectedFiles([]string{"a.go"}, nil, oldCalleeFiles)
+
+	affectedSet := make(map[string]bool, len(affected))
+	for _, f := range affected {
+		affectedSet[f] = true
+	}
+
+	if !affectedSet["a.go"] {
+		t.Error("expected a.go (changed file) in affected set")
+	}
+	if !affectedSet["b.go"] {
+		t.Error("expected b.go (old callee) in affected set — shard needs to drop stale '← FuncA' entry")
+	}
+}
+
+// TestComputeAffectedFiles_CurrentCallersIncluded verifies that files currently
+// calling a function in the changed file are marked affected (existing behaviour).
+func TestComputeAffectedFiles_CurrentCallersIncluded(t *testing.T) {
+	ir := buildIR(
+		[]api.Node{
+			newNode("file-a", []string{"File"}, "filePath", "a.go"),
+			newNode("fn-a", []string{"Function"}, "filePath", "a.go", "name", "FuncA"),
+			newNode("file-c", []string{"File"}, "filePath", "c.go"),
+			newNode("fn-c", []string{"Function"}, "filePath", "c.go", "name", "FuncC"),
+		},
+		[]api.Relationship{
+			// FuncC (in c.go) calls FuncA (in a.go).
+			newRel("calls-2", "calls", "fn-c", "fn-a"),
+		},
+	)
+	d := NewTestDaemon(ir)
+	d.cache = NewCache()
+	d.cache.Build(ir)
+
+	affected := d.computeAffectedFiles([]string{"a.go"}, nil, nil)
+
+	affectedSet := make(map[string]bool, len(affected))
+	for _, f := range affected {
+		affectedSet[f] = true
+	}
+
+	if !affectedSet["c.go"] {
+		t.Error("expected c.go (current caller) in affected set")
+	}
+}

internal/shards/watcher.go

@@ -54,7 +54,7 @@ func (w *Watcher) Run(ctx context.Context) {
 	defer close(w.eventCh)
 
 	w.lastIndexMod = w.gitIndexMtime()
-	w.lastCommitSHA = w.runGit("rev-parse", "HEAD")
+	w.lastCommitSHA = strings.TrimSpace(w.runGit("rev-parse", "HEAD"))
 
 	for {
 		select {