@hominis/fireforge 0.44.4 → 0.46.0

package/dist/src/core/git-diff.js

@@ -1,38 +1,15 @@
 // SPDX-License-Identifier: EUPL-1.2
-import { mkdtemp, rm, stat, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { basename, join } from 'node:path';
+import { stat } from 'node:fs/promises';
+import { join } from 'node:path';
 import { GitError } from '../errors/git.js';
 import { toError } from '../utils/errors.js';
-import { pathExists, readText } from '../utils/fs.js';
+import { pathExists } from '../utils/fs.js';
 import { verbose } from '../utils/logger.js';
-import { exec } from '../utils/process.js';
-import { chunkPathspecs, ensureGit, git } from './git-base.js';
-import { fileExistsInHead, hashObjectBatch, isBinaryFile, listTrackedInHead, } from './git-file-ops.js';
-import { mintDisposableGitIndex, readOnlyGitIndexEnv } from './git-readonly-index.js';
+import { chunkPathspecs, git } from './git-base.js';
+import { readNewFileContent, withForcedBinaryAttribute } from './git-diff-new-file.js';
+import { fileExistsInHead, hashObjectBatch, listTrackedInHead } from './git-file-ops.js';
+import { mintDisposableGitIndex } from './git-readonly-index.js';
 import { getUntrackedFiles, getUntrackedFilesInDir } from './git-status.js';
-async function execGitWithAllowedExitCodes(repoDir, args, allowedExitCodes = [0], envOverride) {
-    // Honour a read-only command's private-index scope: the `--intent-to-add`
-    // / `update-index` staging dance below is a genuine
-    // index write, and inside a read-only command it must land on the
-    // private index, not the primary checkout's.
-    //
-    // `envOverride` wins over that scope: a caller that minted an index for
-    // one specific invocation has said something more specific than the
-    // ambient scope did.
-    const readOnlyIndexEnv = readOnlyGitIndexEnv(repoDir);
-    const env = readOnlyIndexEnv !== undefined || envOverride !== undefined
-        ? { ...readOnlyIndexEnv, ...envOverride }
-        : undefined;
-    const result = await exec('git', args, {
-        cwd: repoDir,
-        ...(env !== undefined ? { env } : {}),
-    });
-    if (allowedExitCodes.includes(result.exitCode)) {
-        return result;
-    }
-    throw new GitError(result.stderr.trim() || 'Git command failed', args.join(' '));
-}
 /**
  * Gets the diff for a specific file.
  *
@@ -46,7 +23,6 @@ async function execGitWithAllowedExitCodes(repoDir, args, allowedExitCodes = [0]
  * @returns Diff content
  */
 export async function getFileDiff(repoDir, filePath) {
-    await ensureGit();
     return git(['diff', '--binary', 'HEAD', '--', filePath], repoDir);
 }
 /**
@@ -113,22 +89,36 @@ function buildNewFileDiffBody(filePath, content, blobHash) {
     return diffLines.join('\n') + '\n';
 }
 /**
- * Generates a unified diff for a new (untracked) file.
+ * Defensive check shared by the new-file readers: a directory here means a
+ * caller bypassed the expansion layers and handed the leaf reader a path it
+ * cannot read. Surfaces an actionable message naming the offending path
+ * rather than the raw `EISDIR` the read would throw. This is a recurring bug
+ * class, hence the guard at every leaf.
+ * @param repoDir - Repository directory
+ * @param filePath - Path to the file (relative to repo)
+ */
+async function rejectDirectory(repoDir, filePath) {
+    const fileStat = await stat(join(repoDir, filePath));
+    if (fileStat.isDirectory()) {
+        throw new GitError(`expected a file but found a directory at '${filePath}' — caller must expand directory entries before diffing`, `hash-object ${filePath}`);
+    }
+}
+/**
+ * Generates a unified diff for a new (untracked) file. A file that is binary
+ * or not valid UTF-8 (see {@link readNewFileContent}) is routed through
+ * {@link generateBinaryFilePatch} instead, because a text body cannot carry
+ * its bytes faithfully.
  * @param repoDir - Repository directory
  * @param filePath - Path to the file (relative to repo)
  * @returns Diff content in unified diff format
  */
 export async function generateNewFileDiff(repoDir, filePath) {
     const fullPath = join(repoDir, filePath);
-    // Defensive check: a directory here means a caller bypassed the expansion
-    // layers and handed the leaf reader a path it cannot read. Surface it with
-    // an actionable message naming the offending path rather than the raw
-    // `EISDIR` that `readText` would throw.
-    const fileStat = await stat(fullPath);
-    if (fileStat.isDirectory()) {
-        throw new GitError(`expected a file but found a directory at '${filePath}' — caller must expand directory entries before diffing`, `hash-object ${filePath}`);
+    await rejectDirectory(repoDir, filePath);
+    const file = await readNewFileContent(repoDir, filePath);
+    if (file.binary) {
+        return generateBinaryFilePatch(repoDir, filePath);
     }
-    const content = await readText(fullPath);
     // Compute the abbreviated git blob hash for the index line
     let blobHash = '0000000000';
     try {
@@ -138,7 +128,7 @@ export async function generateNewFileDiff(repoDir, filePath) {
     catch (error) {
         verbose(`git hash-object failed for ${filePath}; falling back to zero blob hash: ${toError(error).message}`);
     }
-    return buildNewFileDiffBody(filePath, content, blobHash);
+    return buildNewFileDiffBody(filePath, file.content, blobHash);
 }
 /**
  * Generates a patch for a file.
@@ -150,7 +140,6 @@ export async function generateNewFileDiff(repoDir, filePath) {
  * @returns Diff content in unified diff format
  */
 export async function generateFullFilePatch(repoDir, filePath) {
-    await ensureGit();
     // If file exists in HEAD, use standard git diff HEAD -- <file>
     // This generates a contextual diff that is safer for rebasing
     if (await fileExistsInHead(repoDir, filePath)) {
@@ -159,56 +148,6 @@ export async function generateFullFilePatch(repoDir, filePath) {
     // If file is new/untracked, use the full-file "new file" format
     return generateNewFileDiff(repoDir, filePath);
 }
-/**
- * Generates a unified diff between base content and current file content.
- * @param repoDir - Repository directory
- * @param filePath - Path to the file (relative to repo)
- * @param baseContent - The base content to diff against
- * @returns Unified diff in git format
- */
-export async function generateModificationDiff(repoDir, filePath, baseContent) {
-    const fullPath = join(repoDir, filePath);
-    const currentContent = await readText(fullPath);
-    // If contents are identical, return empty diff
-    if (baseContent === currentContent) {
-        return '';
-    }
-    const tempDir = await mkdtemp(join(tmpdir(), 'fireforge-diff-'));
-    const tempFile = join(tempDir, basename(filePath));
-    try {
-        await writeFile(tempFile, baseContent);
-        // git diff --no-index exits code 1 when files differ — that's normal
-        const result = await execGitWithAllowedExitCodes(repoDir, ['diff', '--no-index', '--', tempFile, fullPath], [0, 1]);
-        const output = result.stdout;
-        if (!output) {
-            return '';
-        }
-        // Post-process: fix paths in the diff header only (before the first @@ hunk)
-        const lines = output.split('\n');
-        let pastHeader = false;
-        const fixedLines = lines.map((line) => {
-            if (!pastHeader && line.startsWith('@@')) {
-                pastHeader = true;
-            }
-            if (!pastHeader) {
-                if (line.startsWith('diff --git')) {
-                    return `diff --git a/${filePath} b/${filePath}`;
-                }
-                if (line.startsWith('--- ')) {
-                    return `--- a/${filePath}`;
-                }
-                if (line.startsWith('+++ ')) {
-                    return `+++ b/${filePath}`;
-                }
-            }
-            return line;
-        });
-        return fixedLines.join('\n');
-    }
-    finally {
-        await rm(tempDir, { recursive: true, force: true });
-    }
-}
 /**
  * Gets the diff for all modified files, including untracked (new) files.
  *
@@ -219,16 +158,16 @@ export async function generateModificationDiff(repoDir, filePath, baseContent) {
  * @returns Diff content
  */
 export async function getAllDiff(repoDir) {
-    await ensureGit();
     // Get diff for tracked files
     const trackedDiff = await git(['diff', '--binary', 'HEAD'], repoDir);
     // Get untracked files (properly expanded, not directories)
     const untrackedFiles = await getUntrackedFiles(repoDir);
-    // Classify first. `isBinaryFile` reads the file's first 8 KB directly and
-    // spawns nothing, so the only per-file process in this loop is the
+    // Classify first. `readNewFileContent` reads the file directly and spawns
+    // nothing, so the only per-file process in this loop would be the
     // `git hash-object` inside `generateNewFileDiff` — one spawn per untracked
     // TEXT file, uncapped, against a Firefox tree where "untracked" can mean a
-    // very large number. Hence classify → one batched hash → render.
+    // very large number. Hence classify → one batched hash → render. The
+    // classification carries each text file's content so it is read once.
     //
     // Everything else here is deliberately untouched: `git diff HEAD` (with
     // renames, unlike the `--no-renames` scoped sibling), the `ls-files`
@@ -236,40 +175,33 @@ export async function getAllDiff(repoDir) {
     // sentinel are all observable. `getAllDiff`'s output is SHA-256'd into
     // every tree fingerprint (tree-store.ts) and written verbatim into `.patch`
     // files (export-all.ts), so its bytes are a contract.
-    const binaryFiles = [];
-    const textFiles = [];
+    const classified = new Map();
     for (const file of untrackedFiles) {
-        if (await isBinaryFile(repoDir, file)) {
-            binaryFiles.push(file);
-        }
-        else {
-            textFiles.push(file);
-        }
+        await rejectDirectory(repoDir, file);
+        classified.set(file, await readNewFileContent(repoDir, file));
     }
-    const textHashes = await hashObjectBatch(repoDir, textFiles.map((file) => join(repoDir, file)));
+    const textHashes = await hashObjectBatch(repoDir, untrackedFiles
+        .filter((file) => classified.get(file)?.binary === false)
+        .map((file) => join(repoDir, file)));
     // Binary patches stage into the index and must stay serial; text patches
     // are pure formatting over the already-batched hashes.
     const binaryDiffs = new Map();
-    for (const file of binaryFiles) {
-        binaryDiffs.set(file, await generateBinaryFilePatch(repoDir, file));
+    for (const file of untrackedFiles) {
+        if (classified.get(file)?.binary === true) {
+            binaryDiffs.set(file, await generateBinaryFilePatch(repoDir, file));
+        }
     }
     const untrackedDiffs = [];
     for (const file of untrackedFiles) {
-        const binary = binaryDiffs.get(file);
-        if (binary !== undefined) {
-            untrackedDiffs.push(binary);
+        const entry = classified.get(file);
+        if (entry === undefined || entry.binary) {
+            const binary = binaryDiffs.get(file);
+            if (binary !== undefined)
+                untrackedDiffs.push(binary);
             continue;
         }
         const fullPath = join(repoDir, file);
-        // Same defensive directory check `generateNewFileDiff` carries: a
-        // directory here means a caller bypassed the expansion layers, and its
-        // comment records this as a recurring bug class.
-        const fileStat = await stat(fullPath);
-        if (fileStat.isDirectory()) {
-            throw new GitError(`expected a file but found a directory at '${file}' — caller must expand directory entries before diffing`, `hash-object ${file}`);
-        }
-        const content = await readText(fullPath);
-        untrackedDiffs.push(buildNewFileDiffBody(file, content, abbreviateBlobHash(textHashes.get(fullPath))));
+        untrackedDiffs.push(buildNewFileDiffBody(file, entry.content, abbreviateBlobHash(textHashes.get(fullPath))));
     }
     // Combine all diffs — each already ends with \n, so concatenate directly
     // to avoid inserting blank lines between diff sections.
@@ -376,7 +308,6 @@ async function buildTrackedSections(repoDir, trackedFiles) {
  * @returns Combined diff content
  */
 export async function getDiffForFilesAgainstHead(repoDir, files) {
-    await ensureGit();
     // Expand any directory entries (paths ending with `/`) into their
     // individual untracked files before diffing. `git status --porcelain=v1`
     // reports collapsed untracked directories as `?? dir/`, and every caller
@@ -435,25 +366,27 @@ export async function getDiffForFilesAgainstHead(repoDir, files) {
                 sectionByFile.set(file, innerDiff);
             continue;
         }
-        if (await isBinaryFile(repoDir, file)) {
+        // Binary — by git's NUL heuristic or because the bytes are not valid
+        // UTF-8 — takes the byte-faithful binary-patch arm.
+        const newFile = await readNewFileContent(repoDir, file);
+        if (newFile.binary) {
             const diff = await generateBinaryFilePatch(repoDir, file);
             if (diff.trim())
                 sectionByFile.set(file, diff);
             continue;
         }
-        newTextFiles.push(file);
+        newTextFiles.push({ file, content: newFile.content });
     }
     // Batch 3: blob hashes for every new text file in one `git hash-object`.
     // A miss (rare: a path became unreadable after the stat above) falls back to
     // the zero hash with the same verbose log the per-file path emitted.
-    const blobHashes = await hashObjectBatch(repoDir, newTextFiles.map((file) => join(repoDir, file)));
-    for (const file of newTextFiles) {
-        const fullPath = join(repoDir, file);
-        const fullHash = blobHashes.get(fullPath);
+    const blobHashes = await hashObjectBatch(repoDir, newTextFiles.map(({ file }) => join(repoDir, file)));
+    for (const { file, content } of newTextFiles) {
+        const fullHash = blobHashes.get(join(repoDir, file));
         if (fullHash === undefined) {
             verbose(`git hash-object failed for ${file}; falling back to zero blob hash`);
         }
-        const body = buildNewFileDiffBody(file, await readText(fullPath), abbreviateBlobHash(fullHash));
+        const body = buildNewFileDiffBody(file, content, abbreviateBlobHash(fullHash));
         if (body.trim())
             sectionByFile.set(file, body);
     }
@@ -484,7 +417,6 @@ export async function getDiffForFilesAgainstHead(repoDir, files) {
  * @returns Diff content for the staged files
  */
 export async function getStagedDiffForFiles(repoDir, files) {
-    await ensureGit();
     return git(['diff', '--binary', '--cached', 'HEAD', '--', ...files], repoDir);
 }
 /**
@@ -507,22 +439,31 @@ function runWithBinaryStagingLock(task) {
  * Generates a GIT binary patch for a binary file.
  * For tracked files, uses `git diff --binary HEAD`.
  * For untracked files, temporarily stages with `--intent-to-add` to produce a diff.
+ *
+ * Every `git diff` here runs under {@link withForcedBinaryAttribute}: a
+ * caller sends a file down this arm because a text body cannot carry its
+ * bytes (NUL, or not valid UTF-8), and git's own NUL-only heuristic would
+ * otherwise still render the non-UTF-8 case as text.
  * @param repoDir - Repository directory
  * @param filePath - File path (relative to repo root)
  * @returns The binary diff string, or empty string if no diff
  */
 export async function generateBinaryFilePatch(repoDir, filePath) {
-    await ensureGit();
+    return withForcedBinaryAttribute(filePath, (gitConfigArgs) => generateBinaryFilePatchWithConfig(repoDir, filePath, gitConfigArgs));
+}
+/**
+ * The body of {@link generateBinaryFilePatch}, with the forced-binary config
+ * arguments already resolved.
+ * @param repoDir - Repository directory
+ * @param filePath - File path (relative to repo root)
+ * @param gitConfigArgs - `-c` arguments spliced ahead of every `diff`
+ * @returns The binary diff string, or empty string if no diff
+ */
+async function generateBinaryFilePatchWithConfig(repoDir, filePath, gitConfigArgs) {
     // Try tracked file diff first (read-only — no index lock needed)
-    const result = await execGitWithAllowedExitCodes(repoDir, [
-        'diff',
-        '--binary',
-        'HEAD',
-        '--',
-        filePath,
-    ]);
-    if (result.stdout.trim())
-        return result.stdout;
+    const tracked = await git([...gitConfigArgs, 'diff', '--binary', 'HEAD', '--', filePath], repoDir);
+    if (tracked.trim())
+        return tracked;
     // The diff for an untracked file has to come from an index entry, so one
     // has to be written. Writing it to a PRIVATE index is what keeps that
     // write invisible: the primary `.git/index` never moves, so a concurrent
@@ -539,9 +480,10 @@ export async function generateBinaryFilePatch(repoDir, filePath) {
     const disposable = await mintDisposableGitIndex(repoDir);
     if (disposable !== undefined) {
         try {
-            await execGitWithAllowedExitCodes(repoDir, ['add', '--intent-to-add', '--', filePath], [0], disposable.env);
-            const diffResult = await execGitWithAllowedExitCodes(repoDir, ['diff', '--binary', '--', filePath], [0], disposable.env);
-            return diffResult.stdout;
+            await git(['add', '--intent-to-add', '--', filePath], repoDir, { env: disposable.env });
+            return await git([...gitConfigArgs, 'diff', '--binary', '--', filePath], repoDir, {
+                env: disposable.env,
+            });
         }
         finally {
             await disposable.dispose();
@@ -562,16 +504,10 @@ export async function generateBinaryFilePatch(repoDir, filePath) {
         // between the read-only diff above and this staging block (a concurrent
         // writer, or a staged-add whose worktree file was deleted). Restoring
         // the captured entry is exact regardless of how the entry got there.
-        const priorEntry = (await execGitWithAllowedExitCodes(repoDir, ['ls-files', '--stage', '--', filePath])).stdout;
+        const priorEntry = await git(['ls-files', '--stage', '--', filePath], repoDir);
         try {
-            await execGitWithAllowedExitCodes(repoDir, ['add', '--intent-to-add', '--', filePath]);
-            const diffResult = await execGitWithAllowedExitCodes(repoDir, [
-                'diff',
-                '--binary',
-                '--',
-                filePath,
-            ]);
-            return diffResult.stdout;
+            await git(['add', '--intent-to-add', '--', filePath], repoDir);
+            return await git([...gitConfigArgs, 'diff', '--binary', '--', filePath], repoDir);
         }
         finally {
             await restoreIndexEntry(repoDir, filePath, priorEntry);
@@ -595,13 +531,8 @@ async function restoreIndexEntry(repoDir, filePath, priorEntry) {
     const mode = entryMatch?.[1];
     const oid = entryMatch?.[2];
     if (mode === undefined || oid === undefined) {
-        await execGitWithAllowedExitCodes(repoDir, ['reset', 'HEAD', '--', filePath]);
+        await git(['reset', 'HEAD', '--', filePath], repoDir);
         return;
     }
-    await execGitWithAllowedExitCodes(repoDir, [
-        'update-index',
-        '--add',
-        '--cacheinfo',
-        `${mode},${oid},${filePath}`,
-    ]);
+    await git(['update-index', '--add', '--cacheinfo', `${mode},${oid},${filePath}`], repoDir);
 }

package/dist/src/core/git-file-ops.d.ts

@@ -77,13 +77,6 @@ export declare function hashObjectBatch(repoDir: string, fullPaths: string[]): P
  * @returns File content or null if file doesn't exist at that ref
  */
 export declare function getFileContentAtRef(repoDir: string, filePath: string, ref?: string): Promise<string | null>;
-/**
- * Gets the content of a file from HEAD commit.
- * @param repoDir - Repository directory
- * @param filePath - Path to the file (relative to repo)
- * @returns File content or null if file doesn't exist in HEAD
- */
-export declare function getFileContentFromHead(repoDir: string, filePath: string): Promise<string | null>;
 /**
  * Checks if a file is binary by looking for NUL bytes in the first 8KB.
  * Uses the same heuristic as git.

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

@@ -11,27 +11,16 @@ import { chunkPathspecs, ensureGit, git } from './git-base.js';
  * @param filePath - Path to the file (relative to repo)
  */
 export async function restoreTrackedPath(repoDir, filePath) {
-    await ensureGit();
     await git(['restore', '--source', 'HEAD', '--staged', '--worktree', '--', filePath], repoDir);
 }
-/**
- * Removes an untracked path from disk.
- * @param repoDir - Repository directory
- * @param filePath - Path to the file (relative to repo)
- */
-async function removeUntrackedPath(repoDir, filePath) {
-    const fullPath = join(repoDir, filePath);
-    await removeFile(fullPath);
-}
 /**
  * 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 ensureGit();
     await git(['reset', 'HEAD', '--', filePath], repoDir);
-    await removeUntrackedPath(repoDir, filePath);
+    await removeFile(join(repoDir, filePath));
 }
 /**
  * Discards a status entry according to its git state.
@@ -40,7 +29,7 @@ async function removeAddedPath(repoDir, filePath) {
  */
 export async function discardStatusEntry(repoDir, entry) {
     if (entry.isUntracked) {
-        await removeUntrackedPath(repoDir, entry.file);
+        await removeFile(join(repoDir, entry.file));
         return;
     }
     if (entry.isRenameOrCopy && entry.originalPath) {
@@ -65,7 +54,6 @@ export async function discardStatusEntry(repoDir, entry) {
  * @param files - File paths to stage (relative to repo)
  */
 export async function stageFiles(repoDir, files) {
-    await ensureGit();
     await git(['add', '--', ...files], repoDir);
 }
 /**
@@ -74,7 +62,6 @@ export async function stageFiles(repoDir, files) {
  * @param files - File paths to unstage (relative to repo)
  */
 export async function unstageFiles(repoDir, files) {
-    await ensureGit();
     await git(['reset', 'HEAD', '--', ...files], repoDir);
 }
 /**
@@ -84,7 +71,6 @@ export async function unstageFiles(repoDir, files) {
  * @returns true if file exists in HEAD
  */
 export async function fileExistsInHead(repoDir, filePath) {
-    await ensureGit();
     return (await git(['ls-tree', 'HEAD', '--', filePath], repoDir)).trim().length > 0;
 }
 /**
@@ -107,7 +93,6 @@ export async function listTrackedInHead(repoDir, files) {
     const tracked = new Set();
     if (files.length === 0)
         return tracked;
-    await ensureGit();
     const wanted = new Set(files);
     for (const chunk of chunkPathspecs(files)) {
         const output = await git(['ls-tree', '-r', 'HEAD', '--name-only', '-z', '--', ...chunk], repoDir);
@@ -151,8 +136,8 @@ export async function hashObjectBatch(repoDir, 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 (let i = 0; i < chunk.length; i++) {
-                hashes.set(chunk[i], lines[i]);
+            for (const [i, path] of chunk.entries()) {
+                hashes.set(path, lines[i]);
             }
             continue;
         }
@@ -190,15 +175,6 @@ export async function getFileContentAtRef(repoDir, filePath, ref = 'HEAD') {
     }
     return result.stdout;
 }
-/**
- * Gets the content of a file from HEAD commit.
- * @param repoDir - Repository directory
- * @param filePath - Path to the file (relative to repo)
- * @returns File content or null if file doesn't exist in HEAD
- */
-export async function getFileContentFromHead(repoDir, filePath) {
-    return getFileContentAtRef(repoDir, filePath, 'HEAD');
-}
 /**
  * Checks if a file is binary by looking for NUL bytes in the first 8KB.
  * Uses the same heuristic as git.

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

@@ -43,8 +43,6 @@
  * @returns `{ GIT_INDEX_FILE }` when scoped, otherwise undefined
  */
 export declare function readOnlyGitIndexEnv(cwd: string): Record<string, string> | undefined;
-/** True while a private-index scope is installed (diagnostics and tests). */
-export declare function hasReadOnlyGitIndexScope(): boolean;
 /**
  * Runs `operation` with FireForge's git plumbing pointed at a private
  * index seeded from `repoDir`'s own, so the primary checkout's

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

@@ -64,10 +64,6 @@ export function readOnlyGitIndexEnv(cwd) {
         return undefined;
     return { GIT_INDEX_FILE: activeScope.indexFile };
 }
-/** True while a private-index scope is installed (diagnostics and tests). */
-export function hasReadOnlyGitIndexScope() {
-    return activeScope !== undefined;
-}
 /**
  * Resolves a repository's git directory. Returns undefined for anything
  * that is not a readable git checkout — `engine/` is not always one

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

@@ -1,6 +1,13 @@
 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
  */

package/dist/src/core/git-status.js

@@ -1,8 +1,25 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { warn } from '../utils/logger.js';
-import { ensureGit, git } from './git-base.js';
+import { git } from './git-base.js';
+/**
+ * True when a porcelain status column carries a rename or copy, i.e. the
+ * record is followed by a second NUL-terminated field holding the original
+ * path.
+ * @param column - A single status column character
+ * @returns Whether the column is `R` or `C`
+ */
+function isRenameOrCopyColumn(column) {
+    return column === 'R' || column === 'C';
+}
 /**
  * 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
  */
@@ -18,7 +35,7 @@ export function parsePorcelainStatus(output) {
         const worktreeStatus = record[1] ?? ' ';
         const status = `${indexStatus}${worktreeStatus}`;
         const pathField = record.slice(3);
-        const isRenameOrCopy = indexStatus === 'R' || indexStatus === 'C';
+        const isRenameOrCopy = isRenameOrCopyColumn(indexStatus) || isRenameOrCopyColumn(worktreeStatus);
         const originalPath = isRenameOrCopy ? records[i + 1] : undefined;
         if (isRenameOrCopy) {
             i++;
@@ -42,7 +59,6 @@ export function parsePorcelainStatus(output) {
  * @returns Parsed git status entries
  */
 export async function getWorkingTreeStatus(repoDir) {
-    await ensureGit();
     return parsePorcelainStatus(await git(['status', '--porcelain=v1', '-z'], repoDir));
 }
 /** Default per-directory cap for untracked-directory expansion. */
@@ -57,7 +73,7 @@ export function resolveMaxUntrackedFilesPerDir() {
         return DEFAULT_MAX_UNTRACKED_FILES_PER_DIR;
     const parsed = Number.parseInt(raw, 10);
     if (!Number.isFinite(parsed) || parsed <= 0) {
-        warn(`Ignoring FIREFORGE_MAX_UNTRACKED_FILES="${raw}" — expected a positive integer. Falling back to ${String(DEFAULT_MAX_UNTRACKED_FILES_PER_DIR)}.`);
+        warn(`Ignoring FIREFORGE_MAX_UNTRACKED_FILES="${raw}" — expected a positive integer. Falling back to ${DEFAULT_MAX_UNTRACKED_FILES_PER_DIR}.`);
         return DEFAULT_MAX_UNTRACKED_FILES_PER_DIR;
     }
     return parsed;
@@ -86,7 +102,7 @@ export async function expandUntrackedDirectoryEntries(repoDir, entries) {
         }
         const individualFiles = await getUntrackedFilesInDir(repoDir, entry.file);
         if (individualFiles.length > maxPerDir) {
-            warn(`Untracked directory ${entry.file} contains ${String(individualFiles.length)} files — only the first ${String(maxPerDir)} are listed. Add a .gitignore entry or clean the directory.`);
+            warn(`Untracked directory ${entry.file} contains ${individualFiles.length} files — only the first ${maxPerDir} are listed. Add a .gitignore entry or clean the directory.`);
         }
         for (const file of individualFiles.slice(0, maxPerDir)) {
             expanded.push({
@@ -108,7 +124,6 @@ export async function expandUntrackedDirectoryEntries(repoDir, entries) {
  * @returns List of untracked file paths
  */
 export async function getUntrackedFiles(repoDir) {
-    await ensureGit();
     // Use git ls-files to get all untracked files, which properly expands directories
     const output = await git(['ls-files', '--others', '--exclude-standard'], repoDir);
     return output.split('\n').filter((line) => line.trim().length > 0);
@@ -121,7 +136,6 @@ export async function getUntrackedFiles(repoDir) {
  * @returns List of untracked file paths relative to repo root
  */
 export async function getUntrackedFilesInDir(repoDir, dir) {
-    await ensureGit();
     const output = await git(['ls-files', '--others', '--exclude-standard', '--', dir], repoDir);
     return output.split('\n').filter((line) => line.trim().length > 0);
 }
@@ -133,7 +147,6 @@ export async function getUntrackedFilesInDir(repoDir, dir) {
  * @returns List of modified file paths relative to repo root
  */
 export async function getModifiedFilesInDir(repoDir, dir) {
-    await ensureGit();
     const output = await git(['diff', '--name-only', 'HEAD', '--', dir], repoDir);
     return output.split('\n').filter((line) => line.trim().length > 0);
 }
@@ -146,7 +159,6 @@ export async function getModifiedFilesInDir(repoDir, dir) {
 export async function getDirtyFiles(repoDir, files) {
     if (files.length === 0)
         return [];
-    await ensureGit();
     // Check both staged and unstaged changes for the given files
     const trackedOutput = await git(['diff', '--name-only', 'HEAD', '--', ...files], repoDir);
     const tracked = trackedOutput.split('\n').filter((line) => line.trim().length > 0);

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

@@ -103,12 +103,6 @@ export declare function getCurrentBranch(repoDir: string): Promise<string>;
  * @param repoDir - Repository directory
  */
 export declare function resetChanges(repoDir: string): Promise<void>;
-/**
- * Creates a commit with all current changes.
- * @param repoDir - Repository directory
- * @param message - Commit message
- */
-export declare function commit(repoDir: string, message: string): Promise<void>;
 /**
  * Gets the status of files with their status codes.
  * @param repoDir - Repository directory