Method sync

src/extraction/index.ts:3084–3354

* 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[],
    /**
     * Writer-side WAL pressure valve (#1539). Called after every changed file
     * is stored, when no extraction transaction is open, so a checkpoint can
     * safely catch up before the next file grows the WAL further.
     */
    backpressure?: () => Promise<void> | null,
    /** Inspect changed inputs before deletion/re-extraction cascades their edges. */
    onFileChange?: (filePath: string, content?: string) => void
  )

   * `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[],
    /**
     * Writer-side WAL pressure valve (#1539). Called after every changed file
     * is stored, when no extraction transaction is open, so a checkpoint can
     * safely catch up before the next file grows the WAL further.
     */
    backpressure?: () => Promise<void> | null,
    /** Inspect changed inputs before deletion/re-extraction cascades their edges. */
    onFileChange?: (filePath: string, content?: string) => void
  ): 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[] = [];
    // `file\0name` definition pairs for the files this sync touches, sampled
    // BEFORE their nodes are replaced/deleted. Compared against the post-store
    // pairs below to derive `definitionDelta` (CG-33).
    const pairsBefore = new Set<string>();

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

    const filesToIndex: string[] = [];
    const failedFilePaths: 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()