@hominis/fireforge 0.9.0

package/dist/src/core/patch-apply-fuzz.js

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Fuzzy patch application with escalating fuzz factors.
+ *
+ * Tries an exact `git apply` first, then retries with increasing `--fuzz=N`
+ * values.  If all fuzz levels fail, falls through to `git apply --reject`
+ * so the user gets `.rej` files for manual resolution.
+ */
+import { verbose } from '../utils/logger.js';
+import { exec } from '../utils/process.js';
+import { ensureGit } from './git-base.js';
+// ── Implementation ──
+/**
+ * Attempts to apply a patch with escalating fuzz factors.
+ *
+ * 1. `git apply --check` at fuzz 0 … maxFuzz
+ * 2. `git apply --fuzz=N` at the first passing level
+ * 3. Fall through to `git apply --reject` if nothing succeeds
+ *
+ * @param patchPath - Absolute path to the `.patch` file
+ * @param engineDir - Working directory (engine/)
+ * @param maxFuzz   - Maximum fuzz factor to try (default 3)
+ */
+export async function applyPatchWithFuzz(patchPath, engineDir, maxFuzz = 3) {
+    await ensureGit();
+    // Try exact match first, then escalate
+    for (let fuzz = 0; fuzz <= maxFuzz; fuzz++) {
+        const fuzzArgs = fuzz > 0 ? [`--fuzz=${fuzz}`] : [];
+        const check = await exec('git', ['apply', '--check', ...fuzzArgs, '--', patchPath], {
+            cwd: engineDir,
+        });
+        if (check.exitCode === 0) {
+            // --check passed: apply for real
+            const apply = await exec('git', ['apply', ...fuzzArgs, '--', patchPath], {
+                cwd: engineDir,
+            });
+            if (apply.exitCode === 0) {
+                if (fuzz > 0) {
+                    verbose(`Patch applied with fuzz=${fuzz}: ${patchPath}`);
+                }
+                return { success: true, fuzzFactor: fuzz };
+            }
+            // Unlikely: --check passed but apply failed; fall through to next fuzz
+            verbose(`git apply fuzz=${fuzz} --check passed but apply failed: ${apply.stderr.trim()}`);
+        }
+    }
+    // All fuzz levels failed → generate .rej files for manual resolution
+    const rejectResult = await exec('git', ['apply', '--reject', '--', patchPath], {
+        cwd: engineDir,
+    });
+    const errorMessage = rejectResult.stderr.trim() || 'All fuzz levels failed';
+    // Extract .rej file paths from stderr
+    const rejectFiles = [];
+    for (const line of rejectResult.stderr.split('\n')) {
+        const match = line.match(/Applying patch .* with (\d+) reject/);
+        if (match)
+            continue;
+        const rejMatch = line.match(/Rejected hunk.*to (.+\.rej)/);
+        if (rejMatch?.[1]) {
+            rejectFiles.push(rejMatch[1]);
+        }
+    }
+    return {
+        success: false,
+        fuzzFactor: maxFuzz,
+        error: errorMessage,
+        rejectFiles,
+    };
+}
+//# sourceMappingURL=patch-apply-fuzz.js.map

package/dist/src/core/patch-apply.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Patch orchestration — coordinates patch discovery, application, and validation.
+ * Pure parsing, content transformation, and lock management are in separate modules.
+ */
+import type { ImportSummary, PatchResult } from '../types/commands/index.js';
+export { PatchError } from '../errors/patch.js';
+export { countPatches, discoverPatches, getAllTargetFilesFromPatch, getTargetFileFromPatch, isNewFilePatch, } from './patch-files.js';
+export { withPatchDirectoryLock } from './patch-lock.js';
+export { extractAffectedFiles, extractOrder, isNewFileInPatch, parseHunksForFile, } from './patch-parse.js';
+export { applyPatchToContent, extractNewFileContent } from './patch-transform.js';
+/**
+ * Applies all patches in order. Rolls back all successfully applied
+ * patches when one fails so the engine directory stays clean.
+ * @param patchesDir - Path to the patches directory
+ * @param engineDir - Path to the engine directory
+ * @returns Results for each patch
+ */
+export declare function applyPatches(patchesDir: string, engineDir: string): Promise<PatchResult[]>;
+/**
+ * Validates that all patches can be applied.
+ * @param patchesDir - Path to the patches directory
+ * @param engineDir - Path to the engine directory
+ * @returns Validation results
+ */
+export declare function validatePatches(patchesDir: string, engineDir: string): Promise<{
+    valid: boolean;
+    errors: string[];
+}>;
+/**
+ * Enhanced patch application with continue mode.
+ * When continueOnFailure is false, rolls back all previously applied patches
+ * on the first failure to keep the engine directory in a clean state.
+ * @param patchesDir - Path to the patches directory
+ * @param engineDir - Path to the engine directory
+ * @param continueOnFailure - Whether to continue after failures
+ * @returns Import summary with all results
+ */
+export declare function applyPatchesWithContinue(patchesDir: string, engineDir: string, continueOnFailure?: boolean): Promise<ImportSummary>;
+/**
+ * Computes the cumulative patched content for a file.
+ * @param patchesDir - Path to the patches directory
+ * @param engineDir - Path to the engine directory
+ * @param filePath - File path to compute content for
+ * @returns Content after all patches applied, or null if file doesn't exist
+ */
+export declare function computePatchedContent(patchesDir: string, engineDir: string, filePath: string): Promise<string | null>;

package/dist/src/core/patch-apply.js

@@ -0,0 +1,235 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Patch orchestration — coordinates patch discovery, application, and validation.
+ * Pure parsing, content transformation, and lock management are in separate modules.
+ */
+import { join } from 'node:path';
+import { PatchError } from '../errors/patch.js';
+import { toError } from '../utils/errors.js';
+import { pathExists, readText, writeText } from '../utils/fs.js';
+import { verbose } from '../utils/logger.js';
+import { isContainedRelativePath } from '../utils/paths.js';
+import { exec } from '../utils/process.js';
+import { applyPatchIdempotent, reversePatch } from './git.js';
+import { getFileContentFromHead } from './git-file-ops.js';
+import { discoverPatches } from './patch-files.js';
+import { findPatchesAffectingFile } from './patch-manifest.js';
+import { extractAffectedFiles, extractConflictingFiles, isNewFileInPatch } from './patch-parse.js';
+import { applyPatchToContent, extractNewFileContent } from './patch-transform.js';
+// Re-export from split modules so existing import sites continue working
+export { PatchError } from '../errors/patch.js';
+export { countPatches, discoverPatches, getAllTargetFilesFromPatch, getTargetFileFromPatch, isNewFilePatch, } from './patch-files.js';
+export { withPatchDirectoryLock } from './patch-lock.js';
+export { extractAffectedFiles, extractOrder, isNewFileInPatch, parseHunksForFile, } from './patch-parse.js';
+export { applyPatchToContent, extractNewFileContent } from './patch-transform.js';
+/**
+ * Applies a single patch.
+ * @param patch - Patch info
+ * @param engineDir - Path to the engine directory
+ * @returns Patch result
+ */
+async function applySinglePatch(patch, engineDir) {
+    let patchContent = '';
+    let affectedFiles = [];
+    try {
+        patchContent = await readText(patch.path);
+        affectedFiles = extractAffectedFiles(patchContent);
+        validatePatchTargets(patch, affectedFiles);
+        await applyPatchIdempotent(patch.path, engineDir);
+        return { patch, success: true };
+    }
+    catch (error) {
+        if (error instanceof PatchError) {
+            return { patch, success: false, error: error.message };
+        }
+        const applyError = toError(error);
+        // Check if this is a resolvable "new file" conflict
+        let resolvedNewFiles = false;
+        // Save original content for files we might overwrite, so we can restore on failure
+        const savedContents = new Map();
+        for (const file of affectedFiles) {
+            if (isNewFileInPatch(patchContent, file)) {
+                const targetPath = join(engineDir, file);
+                if (await pathExists(targetPath)) {
+                    savedContents.set(file, await readText(targetPath));
+                    const content = await extractNewFileContent(patch.path, file);
+                    await writeText(targetPath, content);
+                    resolvedNewFiles = true;
+                }
+            }
+        }
+        if (resolvedNewFiles) {
+            try {
+                await applyPatchIdempotent(patch.path, engineDir);
+                return { patch, success: true, autoResolved: true };
+            }
+            catch (retryError) {
+                verbose(`Auto-resolved new-file retry failed for ${patch.filename}: ${toError(retryError).message}`);
+                // Restore original file content before falling through to --reject
+                for (const [file, originalContent] of savedContents) {
+                    await writeText(join(engineDir, file), originalContent);
+                }
+            }
+        }
+        // If it's not a simple new-file conflict, try with --reject to help manual resolution
+        let errorMessage = applyError.message;
+        try {
+            // Use --reject to apply what we can and create .rej files for what we can't
+            await applyPatchIdempotent(patch.path, engineDir, { reject: true });
+            // If this somehow succeeds with --reject but failed without, it still shouldn't
+            // happen because applyPatch first runs --check which would fail.
+            // But if it did succeed, we should still return failure because manual fix is needed
+            // for the rejected hunks.
+        }
+        catch (rejectError) {
+            // This is expected to fail, but now we have .rej files
+            errorMessage = toError(rejectError).message;
+        }
+        return { patch, success: false, error: errorMessage };
+    }
+}
+/**
+ * Reverses previously applied patches in reverse order.
+ * Best-effort: logs warnings for individual failures but does not throw.
+ */
+async function rollbackPatches(results, engineDir) {
+    for (let i = results.length - 1; i >= 0; i--) {
+        const result = results[i];
+        if (!result?.success)
+            continue;
+        try {
+            await reversePatch(result.patch.path, engineDir);
+            verbose(`Rolled back ${result.patch.filename}`);
+        }
+        catch (rollbackError) {
+            verbose(`Failed to roll back ${result.patch.filename}: ${toError(rollbackError).message}`);
+        }
+    }
+}
+/**
+ * Applies all patches in order. Rolls back all successfully applied
+ * patches when one fails so the engine directory stays clean.
+ * @param patchesDir - Path to the patches directory
+ * @param engineDir - Path to the engine directory
+ * @returns Results for each patch
+ */
+export async function applyPatches(patchesDir, engineDir) {
+    const patches = await discoverPatches(patchesDir);
+    const results = [];
+    for (const patch of patches) {
+        const result = await applySinglePatch(patch, engineDir);
+        results.push(result);
+        // Stop on first failure and roll back all previously applied patches
+        if (!result.success) {
+            const succeeded = results.filter((r) => r.success);
+            if (succeeded.length > 0) {
+                verbose(`Rolling back ${succeeded.length} previously applied patch(es)…`);
+                await rollbackPatches(succeeded, engineDir);
+            }
+            break;
+        }
+    }
+    return results;
+}
+/**
+ * Validates that all patches can be applied.
+ * @param patchesDir - Path to the patches directory
+ * @param engineDir - Path to the engine directory
+ * @returns Validation results
+ */
+export async function validatePatches(patchesDir, engineDir) {
+    const patches = await discoverPatches(patchesDir);
+    const errors = [];
+    for (const patch of patches) {
+        try {
+            const patchContent = await readText(patch.path);
+            validatePatchTargets(patch, extractAffectedFiles(patchContent));
+        }
+        catch (error) {
+            errors.push(`${patch.filename}: ${toError(error).message}`);
+            continue;
+        }
+        const result = await exec('git', ['apply', '--check', '--', patch.path], { cwd: engineDir });
+        if (result.exitCode !== 0) {
+            const message = result.stderr.trim() || 'git apply --check failed';
+            errors.push(`${patch.filename}: ${message}`);
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}
+function validatePatchTargets(patch, affectedFiles) {
+    for (const file of affectedFiles) {
+        if (!isContainedRelativePath(file)) {
+            throw new PatchError(`Patch targets a path outside engine/: ${file}`, patch.filename);
+        }
+    }
+}
+/**
+ * Enhanced patch application with continue mode.
+ * When continueOnFailure is false, rolls back all previously applied patches
+ * on the first failure to keep the engine directory in a clean state.
+ * @param patchesDir - Path to the patches directory
+ * @param engineDir - Path to the engine directory
+ * @param continueOnFailure - Whether to continue after failures
+ * @returns Import summary with all results
+ */
+export async function applyPatchesWithContinue(patchesDir, engineDir, continueOnFailure = false) {
+    const patches = await discoverPatches(patchesDir);
+    const succeeded = [];
+    const failed = [];
+    const skipped = [];
+    for (const patch of patches) {
+        const result = await applySinglePatch(patch, engineDir);
+        if (result.success) {
+            succeeded.push(result);
+        }
+        else {
+            // Try to extract conflicting files from error message
+            result.conflictingFiles = extractConflictingFiles(result.error);
+            failed.push(result);
+            if (!continueOnFailure) {
+                // Roll back successfully applied patches to keep engine clean
+                if (succeeded.length > 0) {
+                    verbose(`Rolling back ${succeeded.length} previously applied patch(es)…`);
+                    await rollbackPatches(succeeded, engineDir);
+                }
+                // Mark remaining patches as skipped
+                const currentIndex = patches.indexOf(patch);
+                for (let i = currentIndex + 1; i < patches.length; i++) {
+                    const remainingPatch = patches[i];
+                    if (remainingPatch) {
+                        skipped.push(remainingPatch);
+                    }
+                }
+                break;
+            }
+        }
+    }
+    return {
+        total: patches.length,
+        succeeded,
+        failed,
+        skipped,
+    };
+}
+/**
+ * Computes the cumulative patched content for a file.
+ * @param patchesDir - Path to the patches directory
+ * @param engineDir - Path to the engine directory
+ * @param filePath - File path to compute content for
+ * @returns Content after all patches applied, or null if file doesn't exist
+ */
+export async function computePatchedContent(patchesDir, engineDir, filePath) {
+    let content = await getFileContentFromHead(engineDir, filePath);
+    // Find all patches affecting this file
+    const affectingPatches = await findPatchesAffectingFile(patchesDir, filePath);
+    if (affectingPatches.length === 0) {
+        return content;
+    }
+    // Apply each patch in order
+    for (const { patch } of affectingPatches) {
+        content = await applyPatchToContent(content, patch.path, filePath);
+    }
+    return content;
+}
+//# sourceMappingURL=patch-apply.js.map

package/dist/src/core/patch-export.d.ts

@@ -0,0 +1,99 @@
+import type { PatchCategory, PatchInfo, PatchMetadata } from '../types/commands/index.js';
+/**
+ * Gets the next patch number for a new patch.
+ * @param patchesDir - Path to the patches directory
+ * @returns Next patch number (e.g., "005" for 4 existing patches)
+ */
+export declare function getNextPatchNumber(patchesDir: string): Promise<string>;
+/**
+ * Generates the next patch filename with category.
+ * @param patchesDir - Path to the patches directory
+ * @param category - Patch category
+ * @param name - Human-readable name
+ * @returns Filename like "001-ui-sidebar.patch"
+ */
+export declare function getNextPatchFilename(patchesDir: string, category: PatchCategory, name: string): Promise<string>;
+export interface CommitExportedPatchInput {
+    patchesDir: string;
+    category: PatchCategory;
+    name: string;
+    description: string;
+    diff: string;
+    filesAffected: string[];
+    sourceEsrVersion: string;
+}
+export interface CommitExportedPatchResult {
+    patchFilename: string;
+    metadata: PatchMetadata;
+    superseded: PatchInfo[];
+}
+/**
+ * Commits a freshly generated patch file and manifest update under an exclusive
+ * patch directory lock so concurrent exports cannot allocate the same number.
+ */
+export declare function commitExportedPatch(input: CommitExportedPatchInput): Promise<CommitExportedPatchResult>;
+/**
+ * Parses a patch filename to extract order, category, and name.
+ * Supports both new format (001-category-name.patch) and legacy (001-name.patch).
+ */
+export declare function parseFilename(filename: string): {
+    order: number;
+    category: PatchCategory | null;
+    name: string;
+};
+/**
+ * Finds an existing patch that contains the specified file.
+ * Returns the most recent (highest order) patch if multiple exist.
+ * @param patchesDir - Path to the patches directory
+ * @param filePath - File path to search for
+ * @returns The patch info and metadata, or null if not found
+ */
+export declare function findExistingPatchForFile(patchesDir: string, filePath: string): Promise<{
+    patch: PatchInfo;
+    metadata: PatchMetadata;
+} | null>;
+/**
+ * Updates the content of a patch file.
+ * @param patchPath - Path to the patch file
+ * @param newContent - New patch content
+ */
+export declare function updatePatch(patchPath: string, newContent: string): Promise<void>;
+/**
+ * Updates metadata for a patch in the manifest.
+ * @param patchesDir - Path to the patches directory
+ * @param filename - Patch filename
+ * @param updates - Partial metadata updates
+ */
+export declare function updatePatchMetadata(patchesDir: string, filename: string, updates: Partial<PatchMetadata>): Promise<void>;
+/**
+ * Finds patches that are completely superseded by newer patches.
+ * A patch is superseded if all its affected files are covered by newer patches.
+ * @param patchesDir - Path to the patches directory
+ * @param newPatchFiles - Files affected by the new patch
+ * @param excludeFilename - Filename to exclude from results (the new patch itself)
+ * @returns Superseded patches
+ */
+export declare function findSupersededPatches(patchesDir: string, newPatchFiles: string[], excludeFilename?: string): Promise<PatchInfo[]>;
+/**
+ * Deletes a patch file and removes it from the manifest.
+ * @param patchesDir - Path to the patches directory
+ * @param filename - Patch filename to delete
+ */
+export declare function deletePatch(patchesDir: string, filename: string): Promise<void>;
+/**
+ * Checks whether a patch is fully covered by a new export.
+ * A patch is fully covered when every file it affects is present in the new export.
+ * @param patchFiles - Files affected by the existing patch
+ * @param targetFiles - Files affected by the new export
+ * @returns True when the existing patch is fully covered
+ */
+export declare function isPatchFullyCovered(patchFiles: string[], targetFiles: string[]): boolean;
+/**
+ * Finds patches whose filesAffected entries are fully covered by the specified files.
+ * Used for complete supersession when exporting full-file patches.
+ * @param patchesDir - Path to the patches directory
+ * @param targetFiles - Files affected by the new export
+ * @param excludeFilename - Filename to exclude from results (the new patch itself)
+ * @returns Patches that are fully covered by the new export
+ */
+export declare function findAllPatchesForFiles(patchesDir: string, targetFiles: string[], excludeFilename?: string): Promise<PatchInfo[]>;