@vibe-agent-toolkit/utils 0.2.0-rc.1 → 0.2.0-rc.3

package/dist/git-tracker.d.ts

@@ -56,6 +56,12 @@ export declare class GitTracker {
     private readonly activeSet;
     /** Absolute paths of every directory that contains at least one active-set file. */
     private readonly activeAncestors;
+    /**
+     * Lowercased absolute path → the root-relative path spelled the way git
+     * spelled it. Built from the very same `git ls-files` output `activeSet`
+     * comes from, so it costs one extra `Map` and no extra git invocation.
+     */
+    private readonly indexPaths;
     private initialized;
     private activeSetPopulated;
     /** Whether `git ls-files` actually answered during {@link initialize}. */
@@ -72,8 +78,60 @@ export declare class GitTracker {
      * With `includeUntracked: false`, only tracked files are pre-populated.
      * Untracked non-ignored files will miss the cache and fall through to
      * `git check-ignore` via {@link isIgnored}.
+     *
+     * ## This is the one bracket in the crawl-timing seam's `shared` stratum
+     *
+     * The `git ls-files` spawn below is preparation BOTH crawlers consume and
+     * NEITHER owns — the incumbent link walk and the projection's contributors are
+     * each handed a tracker by their caller — so it is charged to
+     * {@link CRAWL_SHARED_GIT_TRACKER_ID}, in a stratum belonging to no arm.
+     *
+     * The bracket is here, inside the class, and not at the six sites that build a
+     * tracker, for the reason `crawl-timing.ts` gives about `ResourceRegistry`: six
+     * copies are six chances to disagree, and a seventh site added later would
+     * silently go uncharged. Here, every caller is covered by construction — which
+     * includes `@vibe-agent-toolkit/discovery`, a package that could not have filed
+     * a row from its own call site at all, since it depends on `utils` alone.
+     *
+     * The early return above is deliberately OUTSIDE it: a re-entrant call does no
+     * work, and charging it would inflate `calls` with questions rather than
+     * spawns.
      */
     initialize(options?: GitTrackerInitOptions): Promise<void>;
+    /**
+     * The active set read off a snapshot this process has ALREADY taken — or
+     * `null` to say "ask git yourself".
+     *
+     * ## Why this is the same question, not a similar one
+     *
+     * `git ls-files --cached --others --exclude-standard` returns
+     * `tracked ∪ (untracked ∧ ¬ignored)`. A snapshot is `git add --all` **without**
+     * `--force` staged into a throwaway index, whose membership is that same set
+     * by construction — the exclusion of ignored paths is `--force`'s absence in
+     * both cases. So where a snapshot is already in hand, the spawn this method
+     * replaces would re-derive a set the process is already holding.
+     *
+     * It is deliberately a PEEK ({@link peekGitTreeSnapshot}) and never a take: a
+     * snapshot costs a `git add --all`, so causing one to avoid an `ls-files`
+     * would be a large loss dressed as a saving. On the incumbent walk no snapshot
+     * is ever taken, the peek misses, and this tracker spawns exactly as it always
+     * has.
+     *
+     * ## The one divergence, and why it is an improvement
+     *
+     * `--cached` reads the REAL index, so a tracked file deleted from the working
+     * tree is still listed. `git add --all` stages that deletion, so the snapshot
+     * omits it. The set is therefore not identical — it is the same set minus
+     * paths that do not exist, which is what {@link isIgnoredByActiveSet} already
+     * documents the active set to be ("it can only ever contain paths that
+     * EXIST"). The snapshot-sourced set honours that sentence more exactly than
+     * the spawn does.
+     *
+     * @param includeUntracked - The caller's requested membership
+     * @returns Root-relative paths in `git ls-files` shape, or `null` when no
+     *   snapshot is available or the request is one a snapshot cannot answer
+     */
+    private activePathsFromOpenSnapshot;
     /**
      * Did git actually answer, or is this tracker an empty shell?
      *
@@ -139,8 +197,21 @@ export declare class GitTracker {
      * possible per-path spawn.
      *
      * @param absolutePath - Absolute path to check
+     * @param knownToExist - The caller's own answer to the existence question, when
+     *   it has already asked. Supplying it skips this method's `existsSync`, which
+     *   is otherwise paid once per path that is absent from the active set — i.e.
+     *   once per ignored path, and the projection's `filesystem` extent enumerates
+     *   all of them (11,108 calls on an 8,496-path adopter tree).
+     *
+     *   **It must mean what `existsSync` means: `stat` succeeds, following
+     *   symlinks.** A caller holding only an `lstat` result has a DIFFERENT fact —
+     *   `lstat` succeeds on a dangling symlink where `existsSync` returns false —
+     *   and must narrow it to `exists && symlinkResolves !== false` rather than
+     *   pass the `lstat` boolean through, or dangling symlinks silently stop
+     *   falling back to `git check-ignore` and start reporting as ignored.
+     *   Omit it and nothing changes.
      */
-    isIgnoredByActiveSet(absolutePath: string): boolean;
+    isIgnoredByActiveSet(absolutePath: string, knownToExist?: boolean): boolean;
     private isWithinProjectRoot;
     /**
      * Check if a file is ignored by git.
@@ -151,6 +222,28 @@ export declare class GitTracker {
      * @returns true if file is gitignored, false otherwise
      */
     isIgnored(filePath: string): boolean;
+    /**
+     * The spelling git records for a path, or `null` if git has no record of it.
+     *
+     * This is the casing oracle, not another ignore check. On a case-insensitive
+     * filesystem `docs/Readme.md` and `docs/README.md` are one inode with two
+     * spellings, and Node's two `realpath` implementations disagree about which
+     * one they hand back — so anything that derives an identity from a path needs
+     * a single authoritative spelling, and git's is it wherever git has one.
+     *
+     * The lookup key is lowercased, which is the point: the caller asks with
+     * whatever casing it observed and gets back the casing git holds.
+     *
+     * Answers only from the pre-populated set — never spawns. A path git does not
+     * know (untracked-and-ignored, non-existent, outside the project root, or any
+     * path at all when `git ls-files` did not answer) returns `null`, and the
+     * caller falls back to the on-disk casing.
+     *
+     * @param absolutePath - Absolute path to look up
+     * @returns Root-relative, forward-slashed path as git spells it — relative to
+     *   THIS tracker's project root — or `null` when git has no record of it
+     */
+    indexPathFor(absolutePath: string): string | null;
     /**
      * Get cache statistics.
      */

package/dist/git-tracker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"git-tracker.d.ts","sourceRoot":"","sources":["../src/git-tracker.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAQH;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;;;;;;;;OAWG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAS;IAC/C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmC;IACzD,6FAA6F;IAC7F,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0B;IACpD,oFAAoF;IACpF,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA0B;IAC1D,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,kBAAkB,CAAS;IACnC,0EAA0E;IAC1E,OAAO,CAAC,WAAW,CAAS;gBAEhB,WAAW,EAAE,MAAM;IAK/B;;;;;;;;;;;OAWG;IACG,UAAU,CAAC,OAAO,CAAC,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC;IA0BhE;;;;;;;;;;;;;OAaG;IACH,QAAQ,IAAI,OAAO;IAInB;;;;;;;OAOG;IACH,OAAO,CAAC,mBAAmB;IAwB3B;;;;;;;;;;;OAWG;IACH,mBAAmB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO;IAQlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO;IA0BnD,OAAO,CAAC,mBAAmB;IAQ3B;;;;;;;OAOG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAqBpC;;OAEG;IACH,QAAQ,IAAI;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAA;KAAE;IAQrF;;OAEG;IACH,KAAK,IAAI,IAAI;CAQd"}
+{"version":3,"file":"git-tracker.d.ts","sourceRoot":"","sources":["../src/git-tracker.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAcH;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;;;;;;;;OAWG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAS;IAC/C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmC;IACzD,6FAA6F;IAC7F,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0B;IACpD,oFAAoF;IACpF,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA0B;IAC1D;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAkC;IAC7D,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,kBAAkB,CAAS;IACnC,0EAA0E;IAC1E,OAAO,CAAC,WAAW,CAAS;gBAEhB,WAAW,EAAE,MAAM;IAK/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACG,UAAU,CAAC,OAAO,CAAC,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC;IAiChE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,OAAO,CAAC,2BAA2B;IA6BnC;;;;;;;;;;;;;OAaG;IACH,QAAQ,IAAI,OAAO;IAInB;;;;;;;OAOG;IACH,OAAO,CAAC,mBAAmB;IAwB3B;;;;;;;;;;;OAWG;IACH,mBAAmB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO;IAQlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;IACH,oBAAoB,CAAC,YAAY,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,OAAO,GAAG,OAAO;IA2B3E,OAAO,CAAC,mBAAmB;IAQ3B;;;;;;;OAOG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAqBpC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAIjD;;OAEG;IACH,QAAQ,IAAI;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAA;KAAE;IAQrF;;OAEG;IACH,KAAK,IAAI,IAAI;CASd"}

package/dist/git-tracker.js

@@ -6,6 +6,8 @@
  */
 import { existsSync } from 'node:fs';
 import { dirname } from 'node:path';
+import { CRAWL_SHARED_GIT_TRACKER_ID, crawlTimingStart, recordSharedPass, } from './crawl-timing.js';
+import { peekGitTreeSnapshot } from './git-snapshot.js';
 import { gitLsFiles, isGitIgnored } from './git-utils.js';
 import { safePath, toForwardSlash } from './path-utils.js';
 /**
@@ -42,6 +44,12 @@ export class GitTracker {
     activeSet = new Set();
     /** Absolute paths of every directory that contains at least one active-set file. */
     activeAncestors = new Set();
+    /**
+     * Lowercased absolute path → the root-relative path spelled the way git
+     * spelled it. Built from the very same `git ls-files` output `activeSet`
+     * comes from, so it costs one extra `Map` and no extra git invocation.
+     */
+    indexPaths = new Map();
     initialized = false;
     activeSetPopulated = false;
     /** Whether `git ls-files` actually answered during {@link initialize}. */
@@ -61,13 +69,32 @@ export class GitTracker {
      * With `includeUntracked: false`, only tracked files are pre-populated.
      * Untracked non-ignored files will miss the cache and fall through to
      * `git check-ignore` via {@link isIgnored}.
+     *
+     * ## This is the one bracket in the crawl-timing seam's `shared` stratum
+     *
+     * The `git ls-files` spawn below is preparation BOTH crawlers consume and
+     * NEITHER owns — the incumbent link walk and the projection's contributors are
+     * each handed a tracker by their caller — so it is charged to
+     * {@link CRAWL_SHARED_GIT_TRACKER_ID}, in a stratum belonging to no arm.
+     *
+     * The bracket is here, inside the class, and not at the six sites that build a
+     * tracker, for the reason `crawl-timing.ts` gives about `ResourceRegistry`: six
+     * copies are six chances to disagree, and a seventh site added later would
+     * silently go uncharged. Here, every caller is covered by construction — which
+     * includes `@vibe-agent-toolkit/discovery`, a package that could not have filed
+     * a row from its own call site at all, since it depends on `utils` alone.
+     *
+     * The early return above is deliberately OUTSIDE it: a re-entrant call does no
+     * work, and charging it would inflate `calls` with questions rather than
+     * spawns.
      */
     async initialize(options) {
         if (this.initialized) {
             return;
         }
+        const startedAt = crawlTimingStart();
         const includeUntracked = options?.includeUntracked ?? true;
-        const files = gitLsFiles({
+        const files = this.activePathsFromOpenSnapshot(includeUntracked) ?? gitLsFiles({
             cwd: this.projectRoot,
             ...(includeUntracked ? { includeUntracked: true } : {}),
         });
@@ -76,12 +103,78 @@ export class GitTracker {
                 const absolutePath = safePath.resolve(this.projectRoot, relativePath);
                 this.cache.set(absolutePath, false); // false = not ignored
                 this.activeSet.add(absolutePath);
+                this.indexPaths.set(absolutePath.toLowerCase(), toForwardSlash(relativePath));
             }
             this.populateAncestorSet();
         }
         this.gitAnswered = files !== null;
         this.activeSetPopulated = includeUntracked && files !== null;
         this.initialized = true;
+        // After the state above is settled, so a throw from the seam could never
+        // leave a half-initialized tracker; and charged even when git did not answer,
+        // because a failed `git ls-files` still spawned a process and still cost the
+        // command the time it took to fail.
+        recordSharedPass(CRAWL_SHARED_GIT_TRACKER_ID, startedAt);
+    }
+    /**
+     * The active set read off a snapshot this process has ALREADY taken — or
+     * `null` to say "ask git yourself".
+     *
+     * ## Why this is the same question, not a similar one
+     *
+     * `git ls-files --cached --others --exclude-standard` returns
+     * `tracked ∪ (untracked ∧ ¬ignored)`. A snapshot is `git add --all` **without**
+     * `--force` staged into a throwaway index, whose membership is that same set
+     * by construction — the exclusion of ignored paths is `--force`'s absence in
+     * both cases. So where a snapshot is already in hand, the spawn this method
+     * replaces would re-derive a set the process is already holding.
+     *
+     * It is deliberately a PEEK ({@link peekGitTreeSnapshot}) and never a take: a
+     * snapshot costs a `git add --all`, so causing one to avoid an `ls-files`
+     * would be a large loss dressed as a saving. On the incumbent walk no snapshot
+     * is ever taken, the peek misses, and this tracker spawns exactly as it always
+     * has.
+     *
+     * ## The one divergence, and why it is an improvement
+     *
+     * `--cached` reads the REAL index, so a tracked file deleted from the working
+     * tree is still listed. `git add --all` stages that deletion, so the snapshot
+     * omits it. The set is therefore not identical — it is the same set minus
+     * paths that do not exist, which is what {@link isIgnoredByActiveSet} already
+     * documents the active set to be ("it can only ever contain paths that
+     * EXIST"). The snapshot-sourced set honours that sentence more exactly than
+     * the spawn does.
+     *
+     * @param includeUntracked - The caller's requested membership
+     * @returns Root-relative paths in `git ls-files` shape, or `null` when no
+     *   snapshot is available or the request is one a snapshot cannot answer
+     */
+    activePathsFromOpenSnapshot(includeUntracked) {
+        // A snapshot cannot express the tracked-ONLY set: `add --all` stages
+        // untracked-not-ignored files too, and nothing in the result marks which
+        // entries were already tracked. Declining is the only correct answer.
+        if (!includeUntracked)
+            return null;
+        const snapshot = peekGitTreeSnapshot(this.projectRoot);
+        if (snapshot === undefined)
+            return null;
+        const relativePaths = [];
+        for (const entry of snapshot.entries) {
+            // A snapshot covers the whole REPOSITORY, which may be an ancestor of this
+            // tracker's root — `git ls-files` run at that root scopes its listing to
+            // it, so anything above is not this tracker's business and must not enter
+            // the active set. Everything below is kept verbatim, symlinks and
+            // submodule gitlinks included, because `--cached` lists those too.
+            const relativePath = toForwardSlash(safePath.relative(this.normalizedProjectRoot, entry.absolutePath));
+            // A leading `..` SEGMENT, not a `../` prefix: compared as a path segment,
+            // a file legitimately named `..hidden` is kept rather than silently
+            // dropped as if it were an escape.
+            if (relativePath.length === 0 || relativePath.split('/')[0] === '..') {
+                continue;
+            }
+            relativePaths.push(relativePath);
+        }
+        return relativePaths;
     }
     /**
      * Did git actually answer, or is this tracker an empty shell?
@@ -175,8 +268,21 @@ export class GitTracker {
      * possible per-path spawn.
      *
      * @param absolutePath - Absolute path to check
+     * @param knownToExist - The caller's own answer to the existence question, when
+     *   it has already asked. Supplying it skips this method's `existsSync`, which
+     *   is otherwise paid once per path that is absent from the active set — i.e.
+     *   once per ignored path, and the projection's `filesystem` extent enumerates
+     *   all of them (11,108 calls on an 8,496-path adopter tree).
+     *
+     *   **It must mean what `existsSync` means: `stat` succeeds, following
+     *   symlinks.** A caller holding only an `lstat` result has a DIFFERENT fact —
+     *   `lstat` succeeds on a dangling symlink where `existsSync` returns false —
+     *   and must narrow it to `exists && symlinkResolves !== false` rather than
+     *   pass the `lstat` boolean through, or dangling symlinks silently stop
+     *   falling back to `git check-ignore` and start reporting as ignored.
+     *   Omit it and nothing changes.
      */
-    isIgnoredByActiveSet(absolutePath) {
+    isIgnoredByActiveSet(absolutePath, knownToExist) {
         if (!this.activeSetPopulated) {
             return this.isIgnored(absolutePath);
         }
@@ -191,7 +297,8 @@ export class GitTracker {
         // Absent from the active set. That means "ignored" only for a path that is
         // actually there; otherwise the set has no opinion and git must be asked.
         // eslint-disable-next-line security/detect-non-literal-fs-filename -- caller-supplied path, read-only existence probe
-        if (!existsSync(normalized)) {
+        const present = knownToExist ?? existsSync(normalized);
+        if (!present) {
             return this.isIgnored(absolutePath);
         }
         return true;
@@ -228,6 +335,30 @@ export class GitTracker {
         this.cache.set(cacheKey, ignored);
         return ignored;
     }
+    /**
+     * The spelling git records for a path, or `null` if git has no record of it.
+     *
+     * This is the casing oracle, not another ignore check. On a case-insensitive
+     * filesystem `docs/Readme.md` and `docs/README.md` are one inode with two
+     * spellings, and Node's two `realpath` implementations disagree about which
+     * one they hand back — so anything that derives an identity from a path needs
+     * a single authoritative spelling, and git's is it wherever git has one.
+     *
+     * The lookup key is lowercased, which is the point: the caller asks with
+     * whatever casing it observed and gets back the casing git holds.
+     *
+     * Answers only from the pre-populated set — never spawns. A path git does not
+     * know (untracked-and-ignored, non-existent, outside the project root, or any
+     * path at all when `git ls-files` did not answer) returns `null`, and the
+     * caller falls back to the on-disk casing.
+     *
+     * @param absolutePath - Absolute path to look up
+     * @returns Root-relative, forward-slashed path as git spells it — relative to
+     *   THIS tracker's project root — or `null` when git has no record of it
+     */
+    indexPathFor(absolutePath) {
+        return this.indexPaths.get(safePath.resolve(absolutePath).toLowerCase()) ?? null;
+    }
     /**
      * Get cache statistics.
      */
@@ -245,6 +376,7 @@ export class GitTracker {
         this.cache.clear();
         this.activeSet.clear();
         this.activeAncestors.clear();
+        this.indexPaths.clear();
         this.initialized = false;
         this.activeSetPopulated = false;
         this.gitAnswered = false;

package/dist/git-tracker.js.map

@@ -1 +1 @@
-{"version":3,"file":"git-tracker.js","sourceRoot":"","sources":["../src/git-tracker.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"git-tracker.js","sourceRoot":"","sources":["../src/git-tracker.ts"],"names":[],"mappings":"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"}

package/dist/git-utils.d.ts

@@ -43,6 +43,44 @@ export declare function gitLsFiles(options: {
     patterns?: string[];
     includeUntracked?: boolean;
 }): string[] | null;
+/**
+ * List paths git does NOT track, with each wholly-untracked directory collapsed
+ * to a single entry.
+ *
+ * This is the **prune list**, not a file list, and the distinction is the whole
+ * value. `--others --ignored --exclude-standard` alone returns every ignored file
+ * individually: measured on an 8,496-path adopter working tree that is 533,557
+ * paths in 1.19 s — worse than the crawl it was meant to replace, because
+ * `.turbo/cache` alone contributed 418,518 of them. Adding `--directory`
+ * collapses each wholly-ignored directory to one entry: **369 entries in 60 ms**.
+ * A caller can then decide per directory whether to descend, and skip a
+ * half-million paths by name without ever entering them.
+ *
+ * A collapsed directory entry is returned with a trailing `/`, exactly as git
+ * spells it. That is how a caller tells "this whole subtree" from "this one
+ * file", so it is deliberately not normalized away here.
+ *
+ * @param options - Configuration options
+ * @param options.cwd - Working directory inside the repository
+ * @param options.ignored - Restrict to ignored paths. Off, the listing is
+ *   untracked-but-not-ignored paths — which is the only way to see an EMPTY
+ *   untracked directory, since a directory with no files in it is invisible to
+ *   `ls-files` and to any tree object
+ * @param options.directory - Collapse a wholly-untracked directory to one entry
+ * @returns Paths relative to the git root, or null if git did not answer
+ *
+ * @example
+ * ```typescript
+ * // The prune list: where the ignored territory is, without enumerating it.
+ * const prune = gitLsOthers({ cwd: root, ignored: true, directory: true });
+ * // → ['dist/', 'node_modules/', '.turbo/', 'notes.local.md']
+ * ```
+ */
+export declare function gitLsOthers(options: {
+    cwd: string;
+    ignored?: boolean;
+    directory?: boolean;
+}): string[] | null;
 /**
  * Check if a file path is ignored by git
  *

package/dist/git-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"git-utils.d.ts","sourceRoot":"","sources":["../src/git-utils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAYH;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAmB3D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,GAAG,MAAM,EAAE,GAAG,IAAI,CA6ClB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,GAAE,MAAsB,GAAG,OAAO,CAkEnF"}
+{"version":3,"file":"git-utils.d.ts","sourceRoot":"","sources":["../src/git-utils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAUH;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAmB3D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,GAAG,MAAM,EAAE,GAAG,IAAI,CAiClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,GAAG,MAAM,EAAE,GAAG,IAAI,CAuBlB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,GAAE,MAAsB,GAAG,OAAO,CAiDnF"}

package/dist/git-utils.js

@@ -2,11 +2,10 @@
  * Centralized git command wrapper.
  * All git commands should go through this module for consistency and testability.
  */
-import { spawnSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { dirname, parse } from 'node:path';
-import which from 'which';
 import { lookupGitRoot, rememberGitRoot } from './git-root-cache.js';
+import { runGit } from './git-run.js';
 import { safePath } from './path-utils.js';
 /**
  * Find the git repository root by walking up from the given directory.
@@ -62,44 +61,86 @@ export function gitFindRoot(startDir) {
  * ```
  */
 export function gitLsFiles(options) {
-    try {
-        // Resolve git path using which for security (avoids PATH manipulation)
-        const gitPath = which.sync('git');
-        // -z emits NUL-separated, UNQUOTED paths regardless of byte content. Without
-        // it, git quotes any path containing non-ASCII bytes (wraps it in double
-        // quotes with octal escapes, e.g. `café.md` -> `"caf\303\251.md"`), which is
-        // unusable to any exact-string lookup against the real filename.
-        const args = ['ls-files', '-z'];
-        // Include untracked files that aren't gitignored
-        if (options.includeUntracked) {
-            args.push('--cached', '--others', '--exclude-standard');
-        }
-        // Add patterns if provided
-        if (options.patterns && options.patterns.length > 0) {
-            args.push('--', ...options.patterns);
-        }
-        const result = spawnSync(gitPath, args, {
-            cwd: options.cwd,
-            encoding: 'utf-8',
-            stdio: 'pipe',
-            shell: false, // No shell interpreter for security
-        });
-        // Exit code 128 typically means not a git repository
-        if (result.status === 128 || result.error) {
-            return null;
-        }
-        if (result.status !== 0) {
-            return null;
-        }
-        // Parse output into array of file paths. NUL-separated (from -z above), so
-        // no path can ever need trimming or quote-unescaping — a trailing NUL just
-        // produces one empty string at the end, which the filter below drops.
-        return result.stdout.split('\0').filter((line) => line.length > 0);
+    // -z emits NUL-separated, UNQUOTED paths regardless of byte content. Without
+    // it, git quotes any path containing non-ASCII bytes (wraps it in double
+    // quotes with octal escapes, e.g. `café.md` -> `"caf\303\251.md"`), which is
+    // unusable to any exact-string lookup against the real filename.
+    const args = ['ls-files', '-z'];
+    // Include untracked files that aren't gitignored
+    if (options.includeUntracked) {
+        args.push('--cached', '--others', '--exclude-standard');
+    }
+    // Add patterns if provided
+    if (options.patterns && options.patterns.length > 0) {
+        args.push('--', ...options.patterns);
+    }
+    // `trim: false` because the output is NUL-delimited: git sorts by byte value,
+    // so a path beginning with a space sorts FIRST and a trim would silently
+    // rename it to a path that does not exist.
+    const result = runGit(args, { cwd: options.cwd, trim: false });
+    // Every failure means the same thing to this caller — no listing. That covers
+    // "not a repository" (128), git missing entirely, and a listing too large for
+    // the buffer, which `ok` folds in because a truncated answer here is files
+    // silently missing rather than a short list.
+    if (!result.ok) {
+        return null;
+    }
+    // NUL-separated (from -z above), so no path can ever need quote-unescaping —
+    // a trailing NUL just produces one empty string at the end, dropped below.
+    return result.stdout.split('\0').filter((line) => line.length > 0);
+}
+/**
+ * List paths git does NOT track, with each wholly-untracked directory collapsed
+ * to a single entry.
+ *
+ * This is the **prune list**, not a file list, and the distinction is the whole
+ * value. `--others --ignored --exclude-standard` alone returns every ignored file
+ * individually: measured on an 8,496-path adopter working tree that is 533,557
+ * paths in 1.19 s — worse than the crawl it was meant to replace, because
+ * `.turbo/cache` alone contributed 418,518 of them. Adding `--directory`
+ * collapses each wholly-ignored directory to one entry: **369 entries in 60 ms**.
+ * A caller can then decide per directory whether to descend, and skip a
+ * half-million paths by name without ever entering them.
+ *
+ * A collapsed directory entry is returned with a trailing `/`, exactly as git
+ * spells it. That is how a caller tells "this whole subtree" from "this one
+ * file", so it is deliberately not normalized away here.
+ *
+ * @param options - Configuration options
+ * @param options.cwd - Working directory inside the repository
+ * @param options.ignored - Restrict to ignored paths. Off, the listing is
+ *   untracked-but-not-ignored paths — which is the only way to see an EMPTY
+ *   untracked directory, since a directory with no files in it is invisible to
+ *   `ls-files` and to any tree object
+ * @param options.directory - Collapse a wholly-untracked directory to one entry
+ * @returns Paths relative to the git root, or null if git did not answer
+ *
+ * @example
+ * ```typescript
+ * // The prune list: where the ignored territory is, without enumerating it.
+ * const prune = gitLsOthers({ cwd: root, ignored: true, directory: true });
+ * // → ['dist/', 'node_modules/', '.turbo/', 'notes.local.md']
+ * ```
+ */
+export function gitLsOthers(options) {
+    // `--exclude-standard` is unconditional: `--ignored` is rejected outright by
+    // git without an exclude source, and without it the not-ignored listing would
+    // report every ignored path as merely untracked — the exact inversion of what
+    // either caller asked for.
+    const args = ['ls-files', '-z', '--others', '--exclude-standard'];
+    if (options.ignored) {
+        args.push('--ignored');
+    }
+    if (options.directory) {
+        args.push('--directory');
     }
-    catch {
-        // Git not available or other error
+    // See `gitLsFiles`: NUL-delimited output must not be trimmed, or a path
+    // beginning with a space — which git sorts FIRST — comes back renamed.
+    const result = runGit(args, { cwd: options.cwd, trim: false });
+    if (!result.ok) {
         return null;
     }
+    return result.stdout.split('\0').filter((line) => line.length > 0);
 }
 /**
  * Check if a file path is ignored by git
@@ -137,51 +178,33 @@ export function isGitIgnored(filePath, cwd = process.cwd()) {
     if (gitFindRoot(cwd) === null) {
         return false;
     }
-    try {
-        // Resolve git path using which for security (avoids PATH manipulation)
-        const gitPath = which.sync('git');
-        const checkIgnoreArgs = ['check-ignore', '-q'];
-        // git check-ignore returns exit code 0 if file is ignored, 1 if not
-        const result = spawnSync(gitPath, [...checkIgnoreArgs, filePath], {
-            cwd,
-            encoding: 'utf-8',
-            stdio: 'pipe',
-            shell: false, // No shell interpreter for security
-        });
-        if (result.status === 0) {
-            return true;
-        }
-        // Exit code 128 = fatal error (e.g., path beyond a symbolic link).
-        // Walk up ancestor directories to check if a parent is gitignored.
-        // Example: data/ is gitignored, data/symlink/deep/file.md fails with 128,
-        // but checking data/ directly returns 0.
-        if (result.status !== 1) {
-            const resolvedCwd = safePath.resolve(cwd);
-            const resolvedFile = safePath.resolve(cwd, filePath);
-            let current = dirname(resolvedFile);
-            while (current !== resolvedCwd && !current.endsWith(parse(current).root)) {
-                const ancestorResult = spawnSync(gitPath, [...checkIgnoreArgs, current], {
-                    cwd,
-                    encoding: 'utf-8',
-                    stdio: 'pipe',
-                    shell: false,
-                });
-                if (ancestorResult.status === 0) {
-                    return true;
-                }
-                // If this ancestor check also fails fatally, keep walking up
-                // If it returns 1 (not ignored), the parent is tracked — stop walking
-                if (ancestorResult.status === 1) {
-                    break;
-                }
-                current = dirname(current);
+    const checkIgnoreArgs = ['check-ignore', '-q'];
+    // git check-ignore returns exit code 0 if file is ignored, 1 if not
+    const result = runGit([...checkIgnoreArgs, filePath], { cwd });
+    if (result.status === 0) {
+        return true;
+    }
+    // Exit code 128 = fatal error (e.g., path beyond a symbolic link).
+    // Walk up ancestor directories to check if a parent is gitignored.
+    // Example: data/ is gitignored, data/symlink/deep/file.md fails with 128,
+    // but checking data/ directly returns 0.
+    if (result.status !== 1) {
+        const resolvedCwd = safePath.resolve(cwd);
+        const resolvedFile = safePath.resolve(cwd, filePath);
+        let current = dirname(resolvedFile);
+        while (current !== resolvedCwd && !current.endsWith(parse(current).root)) {
+            const ancestorResult = runGit([...checkIgnoreArgs, current], { cwd });
+            if (ancestorResult.status === 0) {
+                return true;
+            }
+            // If this ancestor check also fails fatally, keep walking up
+            // If it returns 1 (not ignored), the parent is tracked — stop walking
+            if (ancestorResult.status === 1) {
+                break;
             }
+            current = dirname(current);
         }
-        return false;
-    }
-    catch {
-        // If git is not available or other error, assume not ignored
-        return false;
     }
+    return false;
 }
 //# sourceMappingURL=git-utils.js.map