Method sync

src/extraction/index.ts:2490–2677

* Sync the index with the current file state. * * Change detection is filesystem-based, never git: a (size, mtime) stat * pre-filter skips unchanged files, then a content-hash compare confirms real * changes. This works in non-git projects and catches committed changes from * `git pul

(
    onProgress?: (progress: IndexProgress) => void,
    /**
     * Watcher fast path: the exact project-relative paths the OS reported as
     * changed. When provided, reconciliation runs over ONLY these paths —
     * per-path logic identical to the full walk (stat pre-filter, hash
     * confirm, the #1240 removal/resurrection flow) — skipping the O(repo)
     * scan and tracked-load. Callers must pass undefined whenever the change
     * set is not exactly known (directory removals, event overflow): the full
     * scan-diff remains the ground truth those cases need (#1285).
     */
    scopedPaths?: string[]
  )

   * `git pull`/`checkout`/`merge`/`rebase` that `git status` cannot see.
   */
  async sync(
    onProgress?: (progress: IndexProgress) => void,
    /**
     * Watcher fast path: the exact project-relative paths the OS reported as
     * changed. When provided, reconciliation runs over ONLY these paths —
     * per-path logic identical to the full walk (stat pre-filter, hash
     * confirm, the #1240 removal/resurrection flow) — skipping the O(repo)
     * scan and tracked-load. Callers must pass undefined whenever the change
     * set is not exactly known (directory removals, event overflow): the full
     * scan-diff remains the ground truth those cases need (#1285).
     */
    scopedPaths?: string[]
  ): Promise<SyncResult> {
    await initGrammars(); // Initialize WASM runtime (grammars loaded lazily below)
    const startTime = Date.now();
    let filesChecked = 0;
    let filesAdded = 0;
    let filesModified = 0;
    let filesRemoved = 0;
    let nodesUpdated = 0;
    const changedFilePaths: string[] = [];

    onProgress?.({
      phase: 'scanning',
      current: 0,
      total: 0,
    });

    const filesToIndex: string[] = [];
    // === Filesystem reconcile (git-independent) ===
    // The source of truth for "what changed" is the filesystem vs the indexed
    // state — never git. We enumerate the current source files and reconcile
    // each against the DB. A cheap (size, mtime) stat pre-filter skips unchanged
    // files without reading or hashing them, so the expensive read+hash+parse
    // only runs for files that actually changed. This catches edits/adds/deletes
    // whether or not the project uses git, and crucially also catches committed
    // changes from `git pull`/`checkout`/`merge`/`rebase` — which `git status`
    // cannot see, because the working tree is clean afterward.
    const tSyncScan = Date.now();
    let currentFiles: string[];
    let trackedFiles: FileRecord[];
    if (scopedPaths && scopedPaths.length > 0) {
      // Scoped reconcile: stat only the reported paths. filesChecked counts
      // the PATHS examined (not the files found) — it must stay non-zero even
      // when every scoped path was a deletion, because CodeGraph.watch()
      // reads `filesChecked === 0 && durationMs === 0` as the
      // lock-unavailable signature (#449).
      const unique = [...new Set(scopedPaths)];
      currentFiles = unique.filter((p) => fs.existsSync(path.join(this.rootDir, p)));
      trackedFiles = [];
      for (const p of unique) {
        const rec = this.queries.getFileByPath(p);
        if (rec) trackedFiles.push(rec);
      }
      filesChecked = unique.length;
      if (process.env.CODEGRAPH_SYNTH_TIMINGS) console.error(`[phase-timing] sync-scoped: ${Date.now() - tSyncScan}ms (${unique.length} paths, ${trackedFiles.length} tracked)`);
    } else {
      currentFiles = await scanDirectoryAsync(this.rootDir);