@hominis/fireforge 0.9.0

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

@@ -0,0 +1,246 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { basename, join } from 'node:path';
+import { toError } from '../utils/errors.js';
+import { pathExists, readText } from '../utils/fs.js';
+import { verbose } from '../utils/logger.js';
+import { exec } from '../utils/process.js';
+import { ensureGit } from './git-base.js';
+import { fileExistsInHead } from './git-file-ops.js';
+import { getUntrackedFiles } from './git-status.js';
+/**
+ * Gets the diff for a specific file.
+ * @param repoDir - Repository directory
+ * @param filePath - Path to the file (relative to repo)
+ * @returns Diff content
+ */
+export async function getFileDiff(repoDir, filePath) {
+    await ensureGit();
+    const result = await exec('git', ['diff', 'HEAD', '--', filePath], { cwd: repoDir });
+    return result.stdout;
+}
+/**
+ * Generates a unified diff for a new (untracked) file.
+ * @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);
+    const content = await readText(fullPath);
+    // Compute the abbreviated git blob hash for the index line
+    let blobHash = '0000000000';
+    try {
+        const hashResult = await exec('git', ['hash-object', fullPath], { cwd: repoDir });
+        const fullHash = hashResult.stdout.trim();
+        if (fullHash.length >= 10) {
+            blobHash = fullHash.slice(0, 10);
+        }
+    }
+    catch (error) {
+        verbose(`git hash-object failed for ${filePath}; falling back to zero blob hash: ${toError(error).message}`);
+    }
+    // Handle empty files
+    if (content.length === 0) {
+        return [
+            `diff --git a/${filePath} b/${filePath}`,
+            'new file mode 100644',
+            `index 0000000000..${blobHash}`,
+            '--- /dev/null',
+            `+++ b/${filePath}`,
+            '',
+        ].join('\n');
+    }
+    const lines = content.split('\n');
+    // Handle files that don't end with newline
+    const hasTrailingNewline = content.endsWith('\n');
+    const lineCount = hasTrailingNewline ? lines.length - 1 : lines.length;
+    // Build the unified diff format for a new file
+    const diffLines = [
+        `diff --git a/${filePath} b/${filePath}`,
+        'new file mode 100644',
+        `index 0000000000..${blobHash}`,
+        '--- /dev/null',
+        `+++ b/${filePath}`,
+        `@@ -0,0 +1,${lineCount} @@`,
+    ];
+    // Add each line with a + prefix
+    for (let i = 0; i < lineCount; i++) {
+        diffLines.push(`+${lines[i]}`);
+    }
+    // Add "No newline at end of file" marker if needed
+    if (!hasTrailingNewline && lineCount > 0) {
+        diffLines.push('\');
+    }
+    return diffLines.join('\n') + '\n';
+}
+/**
+ * Generates a patch for a file.
+ * If the file is tracked in HEAD, it generates a standard contextual diff.
+ * If the file is untracked (new), it generates a "new file" format patch (snapshot).
+ * This ensures standard 3-way mergeable context diffs for existing Mozilla files.
+ * @param repoDir - Repository directory
+ * @param filePath - Path to the file (relative to repo)
+ * @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)) {
+        return getFileDiff(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 exec('git', ['diff', '--no-index', '--', tempFile, fullPath], {
+            cwd: repoDir,
+        });
+        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.
+ * @param repoDir - Repository directory
+ * @returns Diff content
+ */
+export async function getAllDiff(repoDir) {
+    await ensureGit();
+    // Get diff for tracked files
+    const result = await exec('git', ['diff', 'HEAD'], { cwd: repoDir });
+    const trackedDiff = result.stdout;
+    // Get untracked files (properly expanded, not directories)
+    const untrackedFiles = await getUntrackedFiles(repoDir);
+    // Generate diffs for untracked files
+    const untrackedDiffs = [];
+    for (const file of untrackedFiles) {
+        const diff = await generateNewFileDiff(repoDir, file);
+        untrackedDiffs.push(diff);
+    }
+    // Combine all diffs — each already ends with \n, so concatenate directly
+    // to avoid inserting blank lines between diff sections.
+    const allDiffs = [trackedDiff, ...untrackedDiffs].filter((d) => d.trim().length > 0);
+    const combined = allDiffs.join('');
+    return combined.endsWith('\n') ? combined : combined + '\n';
+}
+/**
+ * Builds a combined diff against HEAD for the provided files without touching
+ * the real git index. Tracked files use `git diff HEAD`; untracked files use
+ * synthesized new-file diffs.
+ * @param repoDir - Repository directory
+ * @param files - File paths to diff (relative to repo root)
+ * @returns Combined diff content
+ */
+export async function getDiffForFilesAgainstHead(repoDir, files) {
+    await ensureGit();
+    const uniqueFiles = [...new Set(files)].sort();
+    const diffs = [];
+    for (const file of uniqueFiles) {
+        if (await fileExistsInHead(repoDir, file)) {
+            const diff = await getFileDiff(repoDir, file);
+            if (diff.trim()) {
+                diffs.push(diff);
+            }
+            continue;
+        }
+        if (!(await pathExists(join(repoDir, file)))) {
+            continue;
+        }
+        const diff = await generateNewFileDiff(repoDir, file);
+        if (diff.trim()) {
+            diffs.push(diff);
+        }
+    }
+    if (diffs.length === 0) {
+        return '';
+    }
+    // Each diff from git already ends with \n. Concatenate directly to
+    // preserve context lines (including trailing whitespace-only context)
+    // and avoid inserting blank lines between diff sections.
+    const combined = diffs.join('');
+    return combined.endsWith('\n') ? combined : combined + '\n';
+}
+/**
+ * Generates a combined diff for staged files against HEAD.
+ * @param repoDir - Repository directory
+ * @param files - File paths to diff (relative to repo)
+ * @returns Diff content for the staged files
+ */
+export async function getStagedDiffForFiles(repoDir, files) {
+    await ensureGit();
+    const result = await exec('git', ['diff', '--cached', 'HEAD', '--', ...files], { cwd: repoDir });
+    return result.stdout;
+}
+/**
+ * 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.
+ * @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();
+    // Try tracked file diff first
+    const result = await exec('git', ['diff', '--binary', 'HEAD', '--', filePath], { cwd: repoDir });
+    if (result.stdout.trim())
+        return result.stdout;
+    // For untracked files, stage temporarily to produce a binary diff
+    try {
+        await exec('git', ['add', '--intent-to-add', '--', filePath], { cwd: repoDir });
+        const diffResult = await exec('git', ['diff', '--binary', '--', filePath], { cwd: repoDir });
+        return diffResult.stdout;
+    }
+    finally {
+        // Always unstage, even if diff fails
+        await exec('git', ['reset', 'HEAD', '--', filePath], { cwd: repoDir });
+    }
+}
+//# sourceMappingURL=git-diff.js.map

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

@@ -0,0 +1,65 @@
+import type { GitStatusEntry } from './git-base.js';
+/**
+ * Discards changes to a specific file.
+ * @param repoDir - Repository directory
+ * @param filePath - Path to the file (relative to repo)
+ */
+export declare function discardFile(repoDir: string, filePath: string): Promise<void>;
+/**
+ * Restores a tracked path from HEAD, including staged changes.
+ * @param repoDir - Repository directory
+ * @param filePath - Path to the file (relative to repo)
+ */
+export declare function restoreTrackedPath(repoDir: string, filePath: string): Promise<void>;
+/**
+ * Removes an untracked path from disk.
+ * @param repoDir - Repository directory
+ * @param filePath - Path to the file (relative to repo)
+ */
+export declare function removeUntrackedPath(repoDir: string, filePath: string): Promise<void>;
+/**
+ * Removes a path that is present only in the index/worktree and not in HEAD.
+ * @param repoDir - Repository directory
+ * @param filePath - Path to remove
+ */
+export declare function removeAddedPath(repoDir: string, filePath: string): Promise<void>;
+/**
+ * Discards a status entry according to its git state.
+ * @param repoDir - Repository directory
+ * @param entry - Parsed git status entry
+ */
+export declare function discardStatusEntry(repoDir: string, entry: GitStatusEntry): Promise<void>;
+/**
+ * Stages specific files in the repository.
+ * @param repoDir - Repository directory
+ * @param files - File paths to stage (relative to repo)
+ */
+export declare function stageFiles(repoDir: string, files: string[]): Promise<void>;
+/**
+ * Unstages specific files from the index.
+ * @param repoDir - Repository directory
+ * @param files - File paths to unstage (relative to repo)
+ */
+export declare function unstageFiles(repoDir: string, files: string[]): Promise<void>;
+/**
+ * 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 declare function fileExistsInHead(repoDir: string, filePath: string): Promise<boolean>;
+/**
+ * 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.
+ * @param repoDir - Repository directory
+ * @param filePath - File path (relative to repo root)
+ * @returns true if the file appears to be binary
+ */
+export declare function isBinaryFile(repoDir: string, filePath: string): Promise<boolean>;

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

@@ -0,0 +1,141 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { open } from 'node:fs/promises';
+import { join } from 'node:path';
+import { removeFile } from '../utils/fs.js';
+import { exec } from '../utils/process.js';
+import { ensureGit, git } from './git-base.js';
+/**
+ * Discards changes to a specific file.
+ * @param repoDir - Repository directory
+ * @param filePath - Path to the file (relative to repo)
+ */
+export async function discardFile(repoDir, filePath) {
+    await restoreTrackedPath(repoDir, filePath);
+}
+/**
+ * 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 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)
+ */
+export 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
+ */
+export async function removeAddedPath(repoDir, filePath) {
+    await ensureGit();
+    await exec('git', ['reset', 'HEAD', '--', filePath], { cwd: repoDir });
+    await removeUntrackedPath(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 removeUntrackedPath(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 ensureGit();
+    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 ensureGit();
+    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) {
+    await ensureGit();
+    const result = await exec('git', ['ls-tree', 'HEAD', '--', filePath], { cwd: repoDir });
+    return result.stdout.trim().length > 0;
+}
+/**
+ * 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) {
+    await ensureGit();
+    const result = await exec('git', ['show', `HEAD:${filePath}`], { cwd: repoDir });
+    if (result.exitCode !== 0) {
+        return null;
+    }
+    return result.stdout;
+}
+/**
+ * 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 (error) {
+        void error;
+        return false;
+    }
+}
+//# sourceMappingURL=git-file-ops.js.map

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

@@ -0,0 +1,65 @@
+import type { GitStatusEntry } from './git-base.js';
+/**
+ * Parses NUL-delimited porcelain status output.
+ * @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[]>;
+/**
+ * Expands collapsed untracked directory entries into individual file entries.
+ * Git status may report "?? dir/" instead of listing each file underneath.
+ * @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[]>;
+/**
+ * Gets the list of modified files.
+ * @param repoDir - Repository directory
+ * @returns List of modified file paths
+ */
+export declare function getModifiedFiles(repoDir: string): Promise<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[]>;
+/**
+ * Lists all files in a directory (tracked and untracked, respecting .gitignore).
+ * Combines git ls-files for tracked files and --others for untracked files.
+ * @param repoDir - Repository directory
+ * @param dir - Directory path (relative to repo root)
+ * @returns List of file paths relative to repo root
+ */
+export declare function listAllFilesInDir(repoDir: string, dir: string): Promise<string[]>;

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

@@ -0,0 +1,163 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { exec } from '../utils/process.js';
+import { ensureGit } from './git-base.js';
+/**
+ * Parses NUL-delimited porcelain status output.
+ * @param output - Raw git status output
+ * @returns Parsed entries
+ */
+/** @internal Exported for testing */
+export function parsePorcelainStatus(output) {
+    const records = output.split('\0').filter((record) => record.length > 0);
+    const entries = [];
+    for (let i = 0; i < records.length; i++) {
+        const record = records[i];
+        if (!record || record.length < 4)
+            continue;
+        const indexStatus = record[0] ?? ' ';
+        const worktreeStatus = record[1] ?? ' ';
+        const status = `${indexStatus}${worktreeStatus}`;
+        const pathField = record.slice(3);
+        const isRenameOrCopy = indexStatus === 'R' || indexStatus === 'C';
+        const originalPath = isRenameOrCopy ? records[i + 1] : undefined;
+        if (isRenameOrCopy) {
+            i++;
+        }
+        entries.push({
+            status,
+            indexStatus,
+            worktreeStatus,
+            file: pathField,
+            ...(originalPath !== undefined ? { originalPath } : {}),
+            isUntracked: indexStatus === '?' && worktreeStatus === '?',
+            isRenameOrCopy,
+            isDeleted: indexStatus === 'D' || worktreeStatus === 'D',
+        });
+    }
+    return entries;
+}
+/**
+ * Gets structured working tree status entries.
+ * @param repoDir - Repository directory
+ * @returns Parsed git status entries
+ */
+export async function getWorkingTreeStatus(repoDir) {
+    await ensureGit();
+    const result = await exec('git', ['status', '--porcelain=v1', '-z'], { cwd: repoDir });
+    return parsePorcelainStatus(result.stdout);
+}
+/**
+ * Expands collapsed untracked directory entries into individual file entries.
+ * Git status may report "?? dir/" instead of listing each file underneath.
+ * @param repoDir - Repository directory
+ * @param entries - Parsed status entries
+ * @returns Status entries with untracked directories expanded to individual files
+ */
+export async function expandUntrackedDirectoryEntries(repoDir, entries) {
+    const expanded = [];
+    for (const entry of entries) {
+        if (!entry.isUntracked || !entry.file.endsWith('/')) {
+            expanded.push(entry);
+            continue;
+        }
+        const individualFiles = await getUntrackedFilesInDir(repoDir, entry.file);
+        for (const file of individualFiles) {
+            expanded.push({
+                status: '??',
+                indexStatus: '?',
+                worktreeStatus: '?',
+                file,
+                isUntracked: true,
+                isRenameOrCopy: false,
+                isDeleted: false,
+            });
+        }
+    }
+    return expanded;
+}
+/**
+ * Gets the list of modified files.
+ * @param repoDir - Repository directory
+ * @returns List of modified file paths
+ */
+export async function getModifiedFiles(repoDir) {
+    const entries = await getWorkingTreeStatus(repoDir);
+    return entries.map((entry) => entry.file);
+}
+/**
+ * Gets all untracked files (including files inside untracked directories).
+ * @param repoDir - Repository directory
+ * @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 result = await exec('git', ['ls-files', '--others', '--exclude-standard'], {
+        cwd: repoDir,
+    });
+    return result.stdout.split('\n').filter((line) => line.trim().length > 0);
+}
+/**
+ * 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 async function getUntrackedFilesInDir(repoDir, dir) {
+    await ensureGit();
+    const result = await exec('git', ['ls-files', '--others', '--exclude-standard', '--', dir], {
+        cwd: repoDir,
+    });
+    return result.stdout.split('\n').filter((line) => line.trim().length > 0);
+}
+/**
+ * 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 async function getModifiedFilesInDir(repoDir, dir) {
+    await ensureGit();
+    const result = await exec('git', ['diff', '--name-only', 'HEAD', '--', dir], { cwd: repoDir });
+    return result.stdout.split('\n').filter((line) => line.trim().length > 0);
+}
+/**
+ * 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 async function getDirtyFiles(repoDir, files) {
+    if (files.length === 0)
+        return [];
+    await ensureGit();
+    // Check both staged and unstaged changes for the given files
+    const result = await exec('git', ['diff', '--name-only', 'HEAD', '--', ...files], {
+        cwd: repoDir,
+    });
+    const tracked = result.stdout.split('\n').filter((line) => line.trim().length > 0);
+    // Also check for untracked files
+    const untrackedResult = await exec('git', ['ls-files', '--others', '--exclude-standard', '--', ...files], { cwd: repoDir });
+    const untracked = untrackedResult.stdout.split('\n').filter((line) => line.trim().length > 0);
+    return [...new Set([...tracked, ...untracked])].sort();
+}
+/**
+ * Lists all files in a directory (tracked and untracked, respecting .gitignore).
+ * Combines git ls-files for tracked files and --others for untracked files.
+ * @param repoDir - Repository directory
+ * @param dir - Directory path (relative to repo root)
+ * @returns List of file paths relative to repo root
+ */
+export async function listAllFilesInDir(repoDir, dir) {
+    await ensureGit();
+    const tracked = await exec('git', ['ls-files', '--', dir], { cwd: repoDir });
+    const trackedFiles = tracked.stdout.split('\n').filter((line) => line.trim().length > 0);
+    const untracked = await exec('git', ['ls-files', '--others', '--exclude-standard', '--', dir], {
+        cwd: repoDir,
+    });
+    const untrackedFiles = untracked.stdout.split('\n').filter((line) => line.trim().length > 0);
+    return [...new Set([...trackedFiles, ...untrackedFiles])].sort();
+}
+//# sourceMappingURL=git-status.js.map