fix(cli): make codegraph index a full rebuild so it stops reporting 0 nodes (#874) (#894)

`codegraph index` ran extraction against the already-populated DB without
clearing it first. On an unchanged tree every file's content hash still
matched, so the orchestrator skipped re-inserting all of them and the run
reported its delta (after - before = 0) as "0 nodes, 0 edges" — which read as
if `index` had wiped the graph. `init` only ever differed because it runs on a
freshly created, empty DB.

Clear the existing graph before re-indexing so `index` rebuilds from scratch
and reports the same complete result as a fresh `init`. `--force` keeps its
role as the home-dir/root-path override; `sync` stays the incremental path.

Adds an end-to-end regression test driving the built binary (init -> index),
asserting the graph stays populated and the summary is never "0 nodes, 0 edges".

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

__tests__/index-command.test.ts

@@ -0,0 +1,107 @@
+/**
+ * Regression coverage for issue #874: `codegraph index` produced 0 nodes / 0
+ * edges while `codegraph init` worked, and appeared to wipe the graph.
+ *
+ * Root cause: `index` ran a full extraction against the already-populated DB
+ * without clearing it first. Every file's content hash still matched, so the
+ * orchestrator skipped re-inserting all of them, and the run reported its delta
+ * (after - before = 0) as "0 nodes, 0 edges". The fix makes `index` a true full
+ * rebuild — clear, then re-index — so it produces the same complete result as a
+ * fresh `init`.
+ *
+ * Exercised end-to-end against the built binary so the CLI wiring (not just the
+ * library) is covered.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { execFileSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { CodeGraph } from '../src';
+
+const BIN = path.resolve(__dirname, '../dist/bin/codegraph.js');
+
+function runCodegraph(args: string[], cwd: string): string {
+  return execFileSync(process.execPath, [BIN, ...args], {
+    cwd,
+    encoding: 'utf-8',
+    env: { ...process.env, CODEGRAPH_NO_DAEMON: '1' },
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+}
+
+function graphCounts(dir: string): { nodes: number; edges: number } {
+  const cg = CodeGraph.openSync(dir);
+  try {
+    const stats = cg.getStats();
+    return { nodes: stats.nodeCount, edges: stats.edgeCount };
+  } finally {
+    cg.close();
+  }
+}
+
+describe('codegraph index — full re-index keeps the graph populated (#874)', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codegraph-index-cmd-'));
+    // A couple of files with a call edge so there is a non-trivial graph to
+    // (fail to) reproduce.
+    fs.writeFileSync(
+      path.join(tempDir, 'a.ts'),
+      `export function greet(name: string) { return hello(name); }\n` +
+        `export function hello(n: string) { return 'hi ' + n; }\n`,
+    );
+    fs.writeFileSync(
+      path.join(tempDir, 'b.ts'),
+      `import { greet } from './a';\nexport function main() { return greet('world'); }\n`,
+    );
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('reproduces init\'s node/edge counts instead of emptying the index', () => {
+    runCodegraph(['init'], tempDir);
+    const afterInit = graphCounts(tempDir);
+    expect(afterInit.nodes).toBeGreaterThan(0);
+    expect(afterInit.edges).toBeGreaterThan(0);
+
+    const out = runCodegraph(['index'], tempDir);
+    const afterIndex = graphCounts(tempDir);
+
+    // The graph is still fully populated — `index` rebuilt it, it did not wipe it.
+    expect(afterIndex.nodes).toBe(afterInit.nodes);
+    expect(afterIndex.edges).toBe(afterInit.edges);
+
+    // ...and the CLI reported the real counts, never the misleading "0 nodes".
+    expect(out).not.toMatch(/\b0 nodes, 0 edges\b/);
+    expect(out).toMatch(new RegExp(`\\b${afterInit.nodes} nodes\\b`));
+  });
+
+  it('is idempotent: a second index does not grow the graph', () => {
+    runCodegraph(['init'], tempDir);
+    runCodegraph(['index'], tempDir);
+    const first = graphCounts(tempDir);
+    runCodegraph(['index'], tempDir);
+    const second = graphCounts(tempDir);
+
+    // A clean rebuild each time — no duplicate (re-resolved) edges accumulating
+    // across runs (the C# "+18 edges" symptom in the report).
+    expect(second.nodes).toBe(first.nodes);
+    expect(second.edges).toBe(first.edges);
+  });
+
+  it('--quiet path also rebuilds a populated graph', () => {
+    runCodegraph(['init'], tempDir);
+    const afterInit = graphCounts(tempDir);
+
+    runCodegraph(['index', '--quiet'], tempDir);
+    const afterIndex = graphCounts(tempDir);
+
+    expect(afterIndex.nodes).toBe(afterInit.nodes);
+    expect(afterIndex.edges).toBe(afterInit.edges);
+  });
+});