@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/core/git-file-ops.js

@@ -1,280 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { open } from 'node:fs/promises';
-import { join } from 'node:path';
-import { GitError } from '../errors/git.js';
-import { removeFile } from '../utils/fs.js';
-import { exec } from '../utils/process.js';
-import { execWithInput } from '../utils/process-input.js';
-import { chunkPathspecs, ensureGit, git } from './git-base.js';
-/**
- * Restores a tracked path from HEAD, including staged changes.
- * @param repoDir - Repository directory
- * @param filePath - Path to the file (relative to repo)
- */
-export async function restoreTrackedPath(repoDir, filePath) {
-    await git(['restore', '--source', 'HEAD', '--staged', '--worktree', '--', filePath], repoDir);
-}
-/**
- * Removes a path that is present only in the index/worktree and not in HEAD.
- * @param repoDir - Repository directory
- * @param filePath - Path to remove
- */
-async function removeAddedPath(repoDir, filePath) {
-    await git(['reset', 'HEAD', '--', filePath], repoDir);
-    await removeFile(join(repoDir, filePath));
-}
-/**
- * Discards a status entry according to its git state.
- * @param repoDir - Repository directory
- * @param entry - Parsed git status entry
- */
-export async function discardStatusEntry(repoDir, entry) {
-    if (entry.isUntracked) {
-        await removeFile(join(repoDir, entry.file));
-        return;
-    }
-    if (entry.isRenameOrCopy && entry.originalPath) {
-        await restoreTrackedPath(repoDir, entry.originalPath);
-        if (await fileExistsInHead(repoDir, entry.file)) {
-            await restoreTrackedPath(repoDir, entry.file);
-        }
-        else {
-            await removeAddedPath(repoDir, entry.file);
-        }
-        return;
-    }
-    if (!(await fileExistsInHead(repoDir, entry.file))) {
-        await removeAddedPath(repoDir, entry.file);
-        return;
-    }
-    await restoreTrackedPath(repoDir, entry.file);
-}
-/**
- * Stages specific files in the repository.
- * @param repoDir - Repository directory
- * @param files - File paths to stage (relative to repo)
- */
-export async function stageFiles(repoDir, files) {
-    await git(['add', '--', ...files], repoDir);
-}
-/**
- * Unstages specific files from the index.
- * @param repoDir - Repository directory
- * @param files - File paths to unstage (relative to repo)
- */
-export async function unstageFiles(repoDir, files) {
-    await git(['reset', 'HEAD', '--', ...files], repoDir);
-}
-/**
- * Checks if a file exists in the HEAD commit.
- * @param repoDir - Repository directory
- * @param filePath - Path to the file (relative to repo)
- * @returns true if file exists in HEAD
- */
-export async function fileExistsInHead(repoDir, filePath) {
-    return (await git(['ls-tree', 'HEAD', '--', filePath], repoDir)).trim().length > 0;
-}
-/**
- * Batched equivalent of {@link fileExistsInHead}: returns the subset of
- * `files` that are tracked in HEAD, using a single `git ls-tree` per ARG_MAX
- * chunk instead of one spawn per file. This is the cold-run hot path, and
- * a Firefox-sized checkout has hundreds of affected files.
- *
- * `-r` lists nested blobs by full repo-relative path. `--name-only -z` makes
- * the output a trivial NUL-split with no quoting to undo. Membership in the
- * returned Set is exactly `await fileExistsInHead(repoDir, file)` for any
- * non-directory `file`. Throws (via {@link git}) when HEAD itself is
- * unresolvable, matching the per-file helper's failure mode.
- *
- * @param repoDir - Repository directory
- * @param files - Repo-relative paths to classify
- * @returns The subset of `files` present in HEAD
- */
-export async function listTrackedInHead(repoDir, files) {
-    const tracked = new Set();
-    if (files.length === 0)
-        return tracked;
-    const wanted = new Set(files);
-    for (const chunk of chunkPathspecs(files)) {
-        const output = await git(['ls-tree', '-r', 'HEAD', '--name-only', '-z', '--', ...chunk], repoDir);
-        for (const name of output.split('\0')) {
-            // `ls-tree -r` can surface entries beyond the literal inputs only when an
-            // input is itself a directory in HEAD. Intersect with `wanted` so the
-            // result is always a subset of the requested files, never a superset.
-            if (name.length > 0 && wanted.has(name))
-                tracked.add(name);
-        }
-    }
-    return tracked;
-}
-/**
- * Batched equivalent of the per-file `git hash-object` in
- * {@link import('./git-diff.js').generateNewFileDiff}: computes the git blob
- * hash for every path in one spawn per ARG_MAX chunk and returns a
- * `Map<fullPath, fullHash>`.
- *
- * Uses {@link import('../utils/process.js').exec} rather than {@link git}
- * (which throws on a non-zero exit) because `git hash-object f1 f2 …` is
- * all-or-nothing: it aborts at the first unreadable path and emits nothing
- * for the rest. To keep the per-file contract, where one bad path zeroes
- * only its own index line, a chunk that does not return exactly one hash
- * per input falls back to hashing that chunk's paths individually. A path
- * that is still unhashable is left out of the map. The caller applies the
- * `0000000000` zero-hash fallback for any miss. Hashing stays in git rather
- * than in-process so filters and `.gitattributes` are applied per path and
- * the result cannot diverge under `core.autocrlf`/`text` attributes.
- *
- * @param repoDir - Repository directory
- * @param fullPaths - Absolute file paths to hash
- * @returns Map from each input path to its full blob hash (misses omitted)
- */
-export async function hashObjectBatch(repoDir, fullPaths) {
-    const hashes = new Map();
-    if (fullPaths.length === 0)
-        return hashes;
-    await ensureGit();
-    for (const chunk of chunkPathspecs(fullPaths)) {
-        const result = await exec('git', ['hash-object', '--', ...chunk], { cwd: repoDir });
-        const lines = result.stdout.split('\n').filter((line) => line.length > 0);
-        if (result.exitCode === 0 && lines.length === chunk.length) {
-            for (const [i, path] of chunk.entries()) {
-                hashes.set(path, lines[i]);
-            }
-            continue;
-        }
-        // Batch aborted partway (a path became unreadable between the caller's stat
-        // and here, or otherwise failed). Recover per file so one bad path only
-        // loses its own hash, exactly as the pre-batch per-file code behaved.
-        for (const path of chunk) {
-            const single = await exec('git', ['hash-object', '--', path], { cwd: repoDir });
-            const hash = single.stdout.trim();
-            if (single.exitCode === 0 && hash.length > 0)
-                hashes.set(path, hash);
-        }
-    }
-    return hashes;
-}
-/**
- * Gets the content of a file at a specific git ref (HEAD by default).
- * @param repoDir - Repository directory
- * @param filePath - Path to the file (relative to repo)
- * @param ref - Git ref to read from (commit hash, branch, tag). Defaults to HEAD.
- * @returns File content or null if file doesn't exist at that ref
- */
-export async function getFileContentAtRef(repoDir, filePath, ref = 'HEAD') {
-    await ensureGit();
-    const result = await exec('git', ['show', `${ref}:${filePath}`], { cwd: repoDir });
-    if (result.exitCode !== 0) {
-        const stderr = result.stderr.trim();
-        // Recognise the "file does not exist at this ref" variants across git versions.
-        // The ref name in quotes varies with what was passed (HEAD, a SHA, a tag), so
-        // match loosely rather than interpolating ref into a regex.
-        if (/exists on disk, but not in '[^']*'|path '[^']*' exists, but not '[^']*'|path '[^']*' does not exist in '[^']*'/i.test(stderr)) {
-            return null;
-        }
-        throw new GitError(stderr || 'Git command failed', `show ${ref}:${filePath}`);
-    }
-    return result.stdout;
-}
-/**
- * Batched equivalent of {@link getFileContentAtRef}: reads every path at
- * `ref` through one `git cat-file --batch` process instead of one
- * `git show` per file. A Firefox-sized ownership scan paid 1,493 of those,
- * about 18 ms each and almost all of it spawn overhead.
- *
- * The first request line is `ref` itself, so an unresolvable ref throws a
- * {@link GitError} exactly as the per-file helper does, rather than being
- * read as "every path missing". A path reported `missing` maps to `null`,
- * as the per-file helper returns for a path absent at that ref. Anything
- * the batch cannot answer as a plain blob (a path containing a newline,
- * which the line protocol cannot carry, or an object that is not a blob)
- * is fetched through {@link getFileContentAtRef}, so the result for every
- * path is what that helper returns.
- *
- * @param repoDir - Repository directory
- * @param filePaths - Paths relative to the repository root
- * @param ref - Git ref to read from. Defaults to HEAD.
- * @returns Content (or `null` when absent at `ref`) for every input path
- */
-export async function getFilesContentAtRef(repoDir, filePaths, ref = 'HEAD') {
-    const contents = new Map();
-    const unique = [...new Set(filePaths)];
-    const batchable = unique.filter((path) => !path.includes('\n'));
-    const fallback = unique.filter((path) => path.includes('\n'));
-    if (batchable.length > 0) {
-        await ensureGit();
-        const requests = [ref, ...batchable.map((path) => `${ref}:${path}`)];
-        const result = await execWithInput('git', ['cat-file', '--batch'], requests.join('\n') + '\n', {
-            cwd: repoDir,
-        });
-        if (result.exitCode !== 0) {
-            throw new GitError(result.stderr.trim() || 'git cat-file --batch failed', 'cat-file --batch');
-        }
-        const out = result.stdout;
-        let offset = 0;
-        for (const [index, request] of requests.entries()) {
-            const newline = out.indexOf(0x0a, offset);
-            if (newline === -1) {
-                throw new GitError(`Truncated cat-file --batch output at ${request}`, 'cat-file --batch');
-            }
-            const header = out.toString('utf8', offset, newline);
-            offset = newline + 1;
-            const path = index === 0 ? undefined : batchable[index - 1];
-            if (header.endsWith(' missing') || header.endsWith(' ambiguous')) {
-                if (path === undefined) {
-                    throw new GitError(`Cannot resolve ${ref}: ${header}`, `cat-file --batch ${ref}`);
-                }
-                if (header.endsWith(' missing'))
-                    contents.set(path, null);
-                else
-                    fallback.push(path);
-                continue;
-            }
-            const match = /^[0-9a-f]+ (\S+) (\d+)$/.exec(header);
-            if (!match) {
-                throw new GitError(`Unexpected cat-file --batch header: ${header}`, 'cat-file --batch');
-            }
-            const size = Number(match[2]);
-            const body = out.subarray(offset, offset + size);
-            offset += size + 1;
-            if (path === undefined)
-                continue;
-            if (match[1] === 'blob')
-                contents.set(path, body.toString('utf8'));
-            else
-                fallback.push(path);
-        }
-    }
-    for (const path of fallback) {
-        contents.set(path, await getFileContentAtRef(repoDir, path, ref));
-    }
-    return contents;
-}
-/**
- * Checks if a file is binary by looking for NUL bytes in the first 8KB.
- * Uses the same heuristic as git.
- * @param repoDir - Repository directory
- * @param filePath - File path (relative to repo root)
- * @returns true if the file appears to be binary
- */
-export async function isBinaryFile(repoDir, filePath) {
-    const fullPath = join(repoDir, filePath);
-    try {
-        const fh = await open(fullPath, 'r');
-        try {
-            const buf = Buffer.alloc(8192);
-            const { bytesRead } = await fh.read(buf, 0, 8192, 0);
-            for (let i = 0; i < bytesRead; i++) {
-                if (buf[i] === 0)
-                    return true;
-            }
-            return false;
-        }
-        finally {
-            await fh.close();
-        }
-    }
-    catch {
-        return false;
-    }
-}

package/dist/src/core/git-readonly-index.d.ts

@@ -1,91 +0,0 @@
-/**
- * Private-index scope for FireForge's read-only git plumbing.
- *
- * `git status` and `git diff HEAD` are read-only in the sense operators care
- * about (they never change tracked content), but they are not read-only to
- * git: both refresh the index's stat cache and write `.git/index` (through
- * `.git/index.lock`) when a file's stat data has moved. That makes
- * `fireforge verify` / `lint --per-patch` / `typecheck` a second writer of
- * the primary `engine/` checkout, even when the command was pointed at a CoW
- * tree clone.
- *
- * The consequence is not cosmetic. A concurrent `fireforge test`
- * fingerprints `engine/` before and after the harness run and refuses a
- * verdict taken across a change (`FAIL reason=inconclusive`). That refusal is
- * correct and stays. The defect is FireForge's own read-only commands
- * tripping it.
- *
- * The fix is the standard git one: point the plumbing at a private index
- * (`GIT_INDEX_FILE`) seeded from the repository's own, in a temp directory.
- * Refreshes land there and are thrown away. The primary `.git/index` is
- * never touched, and neither is `.git/index.lock`, which is what makes a
- * concurrent `git status` fail outright rather than merely churn.
- *
- * Fail-open by design: if the git dir or the index cannot be resolved or
- * copied, the scope does not activate and the commands behave exactly as
- * before. A read-only command must not start failing because an optimisation
- * could not be set up.
- *
- * The scope is process-global and non-reentrant on purpose: FireForge
- * commands are one-shot CLI invocations, and nesting two different private
- * indexes for the same run has no meaning. A nested call reuses the outer
- * scope.
- */
-/**
- * Environment overlay a git invocation in `cwd` must carry, or undefined
- * when no private-index scope covers it.
- *
- * Matching is by resolved path prefix: plumbing frequently runs with `cwd`
- * set to a subdirectory of the scoped repository, and those invocations
- * share the same index.
- *
- * @param cwd - Working directory the git process will run in
- * @returns `{ GIT_INDEX_FILE }` when scoped, otherwise undefined
- */
-export declare function readOnlyGitIndexEnv(cwd: string): Record<string, string> | undefined;
-/**
- * Runs `operation` with FireForge's git plumbing pointed at a private
- * index seeded from `repoDir`'s own, so the primary checkout's
- * `.git/index` (and `.git/index.lock`) are never written.
- *
- * @param repoDir - Repository whose plumbing should use a private index
- * @param operation - The read-only command body
- * @returns Whatever `operation` returns
- */
-export declare function withPrivateGitIndex<T>(repoDir: string, operation: () => Promise<T>): Promise<T>;
-/**
- * A private index file plus the cleanup that removes it.
- *
- * `env` is meant to be handed to a single git invocation (or a small
- * sequence of them), rather than installed process-wide the way
- * {@link withPrivateGitIndex} installs a scope.
- */
-export interface DisposableGitIndex {
-    /** Environment overlay pointing git at the private index. */
-    env: Record<string, string>;
-    /** Removes the private index. Never throws. */
-    dispose: () => Promise<void>;
-}
-/**
- * Mints a private index seeded from `repoDir`'s own, for a caller that
- * needs to write the index without the write being visible to anyone else.
- *
- * The distinction from {@link withPrivateGitIndex} matters. That one exists
- * so a read-only command's incidental index refreshes do not touch the
- * primary checkout, and it is process-global, non-reentrant, and fail-open,
- * all of which are right for that job. This one serves a caller whose index
- * write is intentional and whose visibility is the defect: it is per-call, so
- * two concurrent callers cannot collide, and it never depends on an ambient
- * scope having been installed by whichever command happens to be running.
- *
- * The seed is a plain copy, which is safe against a concurrent writer: git
- * writes the index through `index.lock` and an atomic rename, so a reader
- * sees either the old file or the new one, never a torn one. Seeding is
- * required rather than merely tidy: an empty index makes a tracked,
- * unmodified file look like a fresh add.
- *
- * @param repoDir - Repository whose index should be shadowed
- * @returns The overlay and its cleanup, or undefined when one could not be
- *   minted (a non-git directory, an unreadable index, no writable tmpdir)
- */
-export declare function mintDisposableGitIndex(repoDir: string): Promise<DisposableGitIndex | undefined>;

package/dist/src/core/git-readonly-index.js

@@ -1,177 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Private-index scope for FireForge's read-only git plumbing.
- *
- * `git status` and `git diff HEAD` are read-only in the sense operators care
- * about (they never change tracked content), but they are not read-only to
- * git: both refresh the index's stat cache and write `.git/index` (through
- * `.git/index.lock`) when a file's stat data has moved. That makes
- * `fireforge verify` / `lint --per-patch` / `typecheck` a second writer of
- * the primary `engine/` checkout, even when the command was pointed at a CoW
- * tree clone.
- *
- * The consequence is not cosmetic. A concurrent `fireforge test`
- * fingerprints `engine/` before and after the harness run and refuses a
- * verdict taken across a change (`FAIL reason=inconclusive`). That refusal is
- * correct and stays. The defect is FireForge's own read-only commands
- * tripping it.
- *
- * The fix is the standard git one: point the plumbing at a private index
- * (`GIT_INDEX_FILE`) seeded from the repository's own, in a temp directory.
- * Refreshes land there and are thrown away. The primary `.git/index` is
- * never touched, and neither is `.git/index.lock`, which is what makes a
- * concurrent `git status` fail outright rather than merely churn.
- *
- * Fail-open by design: if the git dir or the index cannot be resolved or
- * copied, the scope does not activate and the commands behave exactly as
- * before. A read-only command must not start failing because an optimisation
- * could not be set up.
- *
- * The scope is process-global and non-reentrant on purpose: FireForge
- * commands are one-shot CLI invocations, and nesting two different private
- * indexes for the same run has no meaning. A nested call reuses the outer
- * scope.
- */
-import { copyFile } from 'node:fs/promises';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { toError } from '../utils/errors.js';
-import { pathExists } from '../utils/fs.js';
-import { verbose } from '../utils/logger.js';
-import { exec } from '../utils/process.js';
-/** The active private-index scope, when a read-only command installed one. */
-let activeScope;
-/** Bound on the git-dir probe so a wedged git cannot stall a read-only run. */
-const GIT_DIR_PROBE_TIMEOUT_MS = 30_000;
-/**
- * Environment overlay a git invocation in `cwd` must carry, or undefined
- * when no private-index scope covers it.
- *
- * Matching is by resolved path prefix: plumbing frequently runs with `cwd`
- * set to a subdirectory of the scoped repository, and those invocations
- * share the same index.
- *
- * @param cwd - Working directory the git process will run in
- * @returns `{ GIT_INDEX_FILE }` when scoped, otherwise undefined
- */
-export function readOnlyGitIndexEnv(cwd) {
-    if (activeScope === undefined)
-        return undefined;
-    const resolved = resolve(cwd);
-    const scoped = activeScope.repoDir;
-    if (resolved !== scoped && !resolved.startsWith(`${scoped}/`))
-        return undefined;
-    return { GIT_INDEX_FILE: activeScope.indexFile };
-}
-/**
- * Resolves a repository's git directory. Returns undefined for anything
- * that is not a readable git checkout. `engine/` is not always one
- * (`fireforge download` extracts a source tarball).
- */
-async function resolveGitDir(repoDir) {
-    try {
-        const result = await exec('git', ['rev-parse', '--absolute-git-dir'], {
-            cwd: repoDir,
-            timeout: GIT_DIR_PROBE_TIMEOUT_MS,
-        });
-        if (result.exitCode !== 0)
-            return undefined;
-        const gitDir = result.stdout.trim();
-        return gitDir.length > 0 ? gitDir : undefined;
-    }
-    catch (error) {
-        verbose(`Private git index: could not resolve the git dir — ${toError(error).message}`);
-        return undefined;
-    }
-}
-/**
- * Runs `operation` with FireForge's git plumbing pointed at a private
- * index seeded from `repoDir`'s own, so the primary checkout's
- * `.git/index` (and `.git/index.lock`) are never written.
- *
- * @param repoDir - Repository whose plumbing should use a private index
- * @param operation - The read-only command body
- * @returns Whatever `operation` returns
- */
-export async function withPrivateGitIndex(repoDir, operation) {
-    if (activeScope !== undefined)
-        return operation();
-    const gitDir = await resolveGitDir(repoDir);
-    if (gitDir === undefined)
-        return operation();
-    const minted = await mintPrivateIndex(gitDir);
-    if (minted === undefined)
-        return operation();
-    activeScope = { repoDir: resolve(repoDir), indexFile: minted.indexFile };
-    verbose(`Private git index active for ${repoDir} (${minted.indexFile}).`);
-    try {
-        return await operation();
-    }
-    finally {
-        activeScope = undefined;
-        await minted.dispose();
-    }
-}
-/**
- * Mints a private index seeded from `repoDir`'s own, for a caller that
- * needs to write the index without the write being visible to anyone else.
- *
- * The distinction from {@link withPrivateGitIndex} matters. That one exists
- * so a read-only command's incidental index refreshes do not touch the
- * primary checkout, and it is process-global, non-reentrant, and fail-open,
- * all of which are right for that job. This one serves a caller whose index
- * write is intentional and whose visibility is the defect: it is per-call, so
- * two concurrent callers cannot collide, and it never depends on an ambient
- * scope having been installed by whichever command happens to be running.
- *
- * The seed is a plain copy, which is safe against a concurrent writer: git
- * writes the index through `index.lock` and an atomic rename, so a reader
- * sees either the old file or the new one, never a torn one. Seeding is
- * required rather than merely tidy: an empty index makes a tracked,
- * unmodified file look like a fresh add.
- *
- * @param repoDir - Repository whose index should be shadowed
- * @returns The overlay and its cleanup, or undefined when one could not be
- *   minted (a non-git directory, an unreadable index, no writable tmpdir)
- */
-export async function mintDisposableGitIndex(repoDir) {
-    const gitDir = await resolveGitDir(repoDir);
-    if (gitDir === undefined)
-        return undefined;
-    const minted = await mintPrivateIndex(gitDir);
-    if (minted === undefined)
-        return undefined;
-    return { env: { GIT_INDEX_FILE: minted.indexFile }, dispose: minted.dispose };
-}
-/**
- * Copies `gitDir`'s index into a fresh temp directory. Returns undefined
- * rather than throwing: every caller has a defined behaviour for "no private
- * index available", and none of them wants an exception from an optimisation.
- */
-async function mintPrivateIndex(gitDir) {
-    let tempDir;
-    try {
-        tempDir = await mkdtemp(join(tmpdir(), 'fireforge-roindex-'));
-        const privateIndex = join(tempDir, 'index');
-        const sourceIndex = join(gitDir, 'index');
-        // A repository with no index yet (a fresh init) is fine: git creates
-        // the private one on first use.
-        if (await pathExists(sourceIndex)) {
-            await copyFile(sourceIndex, privateIndex);
-        }
-        const dir = tempDir;
-        return {
-            indexFile: privateIndex,
-            dispose: async () => {
-                await rm(dir, { recursive: true, force: true });
-            },
-        };
-    }
-    catch (error) {
-        verbose(`Private git index unavailable — ${toError(error).message}`);
-        if (tempDir !== undefined)
-            await rm(tempDir, { recursive: true, force: true });
-        return undefined;
-    }
-}

package/dist/src/core/git-status.d.ts

@@ -1,84 +0,0 @@
-import type { GitStatusEntry } from './git-base.js';
-/**
- * Parses NUL-delimited porcelain status output.
- *
- * A rename or copy occupies two NUL records (`XY new\0old\0`), and the `R`/`C`
- * may sit in either column: git >= 2.18 detects renames in the worktree too
- * (`status.renames`), emitting ` R new\0old\0` for an unstaged rename and
- * `RM`/`R ` for a staged one. Only consuming the second record for an index
- * `R`/`C` turned the worktree form's `old` field into a bogus extra entry
- * whose status was whatever its first two path characters happened to be.
- * @param output - Raw git status output
- * @returns Parsed entries
- */
-/** @internal Exported for testing */
-export declare function parsePorcelainStatus(output: string): GitStatusEntry[];
-/**
- * Gets structured working tree status entries.
- * @param repoDir - Repository directory
- * @returns Parsed git status entries
- */
-export declare function getWorkingTreeStatus(repoDir: string): Promise<GitStatusEntry[]>;
-/**
- * Resolves the per-directory expansion cap, honoring the same
- * FIREFORGE_MAX_UNTRACKED_FILES override the status command documents.
- */
-export declare function resolveMaxUntrackedFilesPerDir(): number;
-/**
- * Expands collapsed untracked directory entries into individual file entries.
- * Git status may report "?? dir/" instead of listing each file underneath.
- *
- * Expansion is capped per directory (FIREFORGE_MAX_UNTRACKED_FILES, default
- * 5000) with a warning on overflow. Without the cap, `reset --dry-run` after
- * an interrupted download (unborn HEAD, the entire ~300k file tree
- * untracked) enumerates and prints every file.
- *
- * @param repoDir - Repository directory
- * @param entries - Parsed status entries
- * @returns Status entries with untracked directories expanded to individual
- *   files
- */
-export declare function expandUntrackedDirectoryEntries(repoDir: string, entries: GitStatusEntry[]): Promise<GitStatusEntry[]>;
-/**
- * Lists the untracked files under each collapsed `dir/` status entry with
- * one `git ls-files` per ARG_MAX chunk, instead of one spawn per directory
- * (a Firefox-sized worktree scan paid 73 of them). The result maps every
- * requested directory to its files in git's order, which is exactly what
- * {@link getUntrackedFilesInDir} returns for that directory alone. `-z`
- * keeps non-ASCII names literal: the newline form C-quotes them under
- * git's default `core.quotePath`, and a quoted path names no file.
- *
- * @param repoDir - Repository directory
- * @param dirs - Collapsed untracked directories, each ending in `/`
- * @returns Files per directory (every input key present, possibly empty)
- */
-export declare function listUntrackedFilesInDirs(repoDir: string, dirs: readonly string[]): Promise<Map<string, string[]>>;
-/**
- * Gets all untracked files (including files inside untracked directories).
- * @param repoDir - Repository directory
- * @returns List of untracked file paths
- */
-export declare function getUntrackedFiles(repoDir: string): Promise<string[]>;
-/**
- * Gets untracked files within a specific directory.
- * Uses path-scoped git ls-files for efficiency in large repos.
- * @param repoDir - Repository directory
- * @param dir - Directory path (relative to repo root)
- * @returns List of untracked file paths relative to repo root
- */
-export declare function getUntrackedFilesInDir(repoDir: string, dir: string): Promise<string[]>;
-/**
- * Gets modified (tracked) files within a specific directory.
- * Uses path-scoped git diff for efficiency in large repos.
- * @param repoDir - Repository directory
- * @param dir - Directory path (relative to repo root)
- * @returns List of modified file paths relative to repo root
- */
-export declare function getModifiedFilesInDir(repoDir: string, dir: string): Promise<string[]>;
-/**
- * Checks if any of the specified files have uncommitted changes.
- * @param repoDir - Repository directory
- * @param files - File paths to check (relative to repo root)
- * @returns List of dirty file paths
- */
-export declare function getDirtyFiles(repoDir: string, files: string[]): Promise<string[]>;