@hominis/fireforge 0.55.0 → 0.60.0

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

@@ -1,208 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { warn } from '../utils/logger.js';
-import { chunkPathspecs, 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
- */
-/** @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 = isRenameOrCopyColumn(indexStatus) || isRenameOrCopyColumn(worktreeStatus);
-        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) {
-    return parsePorcelainStatus(await git(['status', '--porcelain=v1', '-z'], repoDir));
-}
-/** Default per-directory cap for untracked-directory expansion. */
-const DEFAULT_MAX_UNTRACKED_FILES_PER_DIR = 5000;
-/**
- * Resolves the per-directory expansion cap, honoring the same
- * FIREFORGE_MAX_UNTRACKED_FILES override the status command documents.
- */
-export function resolveMaxUntrackedFilesPerDir() {
-    const raw = process.env['FIREFORGE_MAX_UNTRACKED_FILES'];
-    if (raw === undefined || raw.length === 0)
-        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 ${DEFAULT_MAX_UNTRACKED_FILES_PER_DIR}.`);
-        return DEFAULT_MAX_UNTRACKED_FILES_PER_DIR;
-    }
-    return parsed;
-}
-/**
- * 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 async function expandUntrackedDirectoryEntries(repoDir, entries) {
-    const expanded = [];
-    const maxPerDir = resolveMaxUntrackedFilesPerDir();
-    const collapsed = entries
-        .filter((entry) => entry.isUntracked && entry.file.endsWith('/'))
-        .map((entry) => entry.file);
-    const untrackedByDir = await listUntrackedFilesInDirs(repoDir, collapsed);
-    for (const entry of entries) {
-        if (!entry.isUntracked || !entry.file.endsWith('/')) {
-            expanded.push(entry);
-            continue;
-        }
-        const individualFiles = untrackedByDir.get(entry.file) ?? [];
-        if (individualFiles.length > maxPerDir) {
-            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({
-                status: '??',
-                indexStatus: '?',
-                worktreeStatus: '?',
-                file,
-                isUntracked: true,
-                isRenameOrCopy: false,
-                isDeleted: false,
-            });
-        }
-    }
-    return expanded;
-}
-/**
- * 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 async function listUntrackedFilesInDirs(repoDir, dirs) {
-    const byDir = new Map(dirs.map((dir) => [dir, []]));
-    if (byDir.size === 0)
-        return byDir;
-    for (const chunk of chunkPathspecs([...byDir.keys()])) {
-        const output = await git(['ls-files', '--others', '--exclude-standard', '-z', '--', ...chunk], repoDir);
-        for (const file of output.split('\0')) {
-            if (file.length === 0)
-                continue;
-            // Collapsed status directories never nest, so the first matching
-            // ancestor is the only one.
-            for (let slash = file.indexOf('/'); slash !== -1; slash = file.indexOf('/', slash + 1)) {
-                const bucket = byDir.get(file.slice(0, slash + 1));
-                if (bucket !== undefined) {
-                    bucket.push(file);
-                    break;
-                }
-            }
-        }
-    }
-    return byDir;
-}
-/**
- * Gets all untracked files (including files inside untracked directories).
- * @param repoDir - Repository directory
- * @returns List of untracked file paths
- */
-export async function getUntrackedFiles(repoDir) {
-    // 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);
-}
-/**
- * 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) {
-    const output = await git(['ls-files', '--others', '--exclude-standard', '--', dir], repoDir);
-    return output.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) {
-    const output = await git(['diff', '--name-only', 'HEAD', '--', dir], repoDir);
-    return output.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 [];
-    // 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);
-    // Also check for untracked files
-    const untrackedOutput = await git(['ls-files', '--others', '--exclude-standard', '--', ...files], repoDir);
-    const untracked = untrackedOutput.split('\n').filter((line) => line.trim().length > 0);
-    return [...new Set([...tracked, ...untracked])].sort();
-}

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

@@ -1,114 +0,0 @@
-/**
- * Checks if a directory is a git repository.
- * @param dir - Directory to check
- * @returns True if the directory is a git repository
- */
-export declare function isGitRepository(dir: string): Promise<boolean>;
-/**
- * Ensures the repository has an "origin" remote.
- *
- * Firefox's mach bootstrap and build scripts shell out to
- * `git remote get-url origin` and emit noisy errors when the remote is
- * absent.  This adds a local-only dummy remote so those scripts stay quiet.
- * Nothing is ever fetched from or pushed to this remote.
- *
- * @param dir - Git working directory
- */
-export declare function ensureOriginRemote(dir: string): Promise<void>;
-/**
- * Stages all files in the repository.
- * Tries a monolithic `git add -A` first. If that times out, falls back to
- * directory-by-directory staged adds.
- */
-export declare function stageAllFiles(dir: string, options?: {
-    onProgress?: (message: string) => void;
-    timeout?: number;
-}): Promise<void>;
-/**
- * Initializes a new git repository with an orphan branch.
- * @param dir - Directory to initialize
- * @param branchName - Name for the initial branch
- */
-export declare function initRepository(dir: string, branchName?: string, options?: {
-    onProgress?: (message: string) => void;
-}): Promise<void>;
-/**
- * Resumes a partially initialized git repository (e.g. after a killed
- * `git add -A` left an unborn HEAD).  Re-applies performance settings,
- * cleans up stale locks, stages all files, and creates the initial commit.
- */
-export declare function resumeRepository(dir: string, options?: {
-    onProgress?: (message: string) => void;
-}): Promise<void>;
-/**
- * Applies a patch file using git apply.
- * @param patchPath - Path to the patch file
- * @param repoDir - Repository directory
- * @param options - Application options
- */
-export declare function applyPatch(patchPath: string, repoDir: string, options?: {
-    reject?: boolean;
-}): Promise<void>;
-/**
- * Applies a patch idempotently using reverse-forward pattern. First tries to
- * reverse the patch (in case it is already applied), then applies it forward.
- *
- * @param patchPath - Path to the patch file
- * @param repoDir - Repository directory
- * @param options.reject - Fall back to `git apply --reject`
- * @param options.protectedFiles - Files that must not be reset to HEAD by the
- *   recovery step. Callers applying a patch queue pass the files already
- *   touched by previously applied patches in the same run: two overlapping
- *   patches (an `--allow-overlap` queue) share files, and a blanket
- *   `checkout HEAD` would wipe the earlier patch's changes from the shared
- *   file before applying the later one, leaving the engine in a hybrid state
- *   the summary never describes.
- */
-export declare function applyPatchIdempotent(patchPath: string, repoDir: string, options?: {
-    reject?: boolean;
-    protectedFiles?: ReadonlySet<string>;
-}): Promise<void>;
-/**
- * Reverses a previously applied patch.
- * @param patchPath - Path to the patch file
- * @param repoDir - Repository directory
- */
-export declare function reversePatch(patchPath: string, repoDir: string): Promise<void>;
-/**
- * Checks if the repository has uncommitted changes.
- * @param repoDir - Repository directory
- * @returns True if there are uncommitted changes
- */
-export declare function hasChanges(repoDir: string): Promise<boolean>;
-/**
- * Checks whether an error indicates the repository has no HEAD (e.g. unborn branch).
- * @param error - The error to check
- * @returns True if the error is a missing-HEAD error
- */
-export declare function isMissingHeadError(error: unknown): boolean;
-/**
- * Gets the current HEAD commit hash.
- * @param repoDir - Repository directory
- * @returns Commit hash
- */
-export declare function getHead(repoDir: string): Promise<string>;
-/**
- * Gets the current branch name.
- * @param repoDir - Repository directory
- * @returns Branch name
- */
-export declare function getCurrentBranch(repoDir: string): Promise<string>;
-/**
- * Resets all changes in the repository.
- * @param repoDir - Repository directory
- */
-export declare function resetChanges(repoDir: string): Promise<void>;
-/**
- * Gets the status of files with their status codes.
- * @param repoDir - Repository directory
- * @returns Array of [status, filepath] tuples
- */
-export declare function getStatusWithCodes(repoDir: string): Promise<Array<{
-    status: string;
-    file: string;
-}>>;