@hominis/fireforge 0.40.0 → 0.42.0

package/dist/src/commands/re-export-scan.js

@@ -9,10 +9,13 @@ import { buildModifiedFileAdditionsFromDiff, buildPatchQueueContext, detectNewFi
 import { getClaimedFiles } from '../core/patch-manifest.js';
 import { extractNewFileContentFromDiff } from '../core/patch-transform.js';
 import { GeneralError, InvalidArgumentError } from '../errors/base.js';
+import { mapWithConcurrency } from '../utils/concurrency.js';
 import { pathExists } from '../utils/fs.js';
 import { cancel, info, isCancel, warn } from '../utils/logger.js';
 import { isContainedRelativePath, normalizePathSlashes, stripEnginePrefix, } from '../utils/paths.js';
 const SCAN_ADD_COUNT_THRESHOLD = 3;
+/** Concurrency bound for existence probes (matches the classify/lint pools). */
+const PATH_PROBE_CONCURRENCY = 8;
 const SCAN_DIR_COUNT_THRESHOLD = 2;
 /** Normalizes repeatable `--scan-file` inputs into safe engine-relative paths. */
 export function normalizeScanFiles(scanFiles) {
@@ -70,11 +73,18 @@ async function scanPatchFilesTargeted(args) {
     const currentSet = new Set(currentFilesAffected);
     const claimedByOthers = getClaimedFiles(manifest, patchFilename);
     const added = [];
+    // Phase-split for bounded concurrency: the sync claimed-by-others check
+    // first (first offender in argument order, as before), then pooled
+    // existence probes with the refusal chosen by ordered iteration so the
+    // FIRST missing file in argument order is named deterministically.
     for (const file of scanFiles) {
         if (claimedByOthers.has(file)) {
             throw new InvalidArgumentError(`--scan-file path is already claimed by another patch: ${file}`, '--scan-file');
         }
-        if (!(await pathExists(join(engineDir, file)))) {
+    }
+    const exists = await mapWithConcurrency(scanFiles, PATH_PROBE_CONCURRENCY, (file) => pathExists(join(engineDir, file)));
+    for (const [index, file] of scanFiles.entries()) {
+        if (exists[index] !== true) {
             throw new InvalidArgumentError(`--scan-file path not found in engine/: ${file}`, '--scan-file');
         }
         if (!currentSet.has(file))
@@ -84,12 +94,8 @@ async function scanPatchFilesTargeted(args) {
     return reportScanResult(currentFilesAffected, patchFilename, isDryRun, added.sort(), removed);
 }
 async function findRemovedFiles(files, engineDir) {
-    const removed = [];
-    for (const file of files) {
-        if (!(await pathExists(join(engineDir, file))))
-            removed.push(file);
-    }
-    return removed.sort();
+    const exists = await mapWithConcurrency(files, PATH_PROBE_CONCURRENCY, (file) => pathExists(join(engineDir, file)));
+    return files.filter((_, index) => exists[index] !== true).sort();
 }
 function reportScanResult(currentFilesAffected, patchFilename, isDryRun, added, removed) {
     for (const f of added)

package/dist/src/commands/re-export-single.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Single-patch refresh core for `fireforge re-export`, split out of
+ * `re-export.ts` (at the per-file line budget after the FORGE J1/J2
+ * hoisted-lint and foreign-drift wiring). The orchestrator loop calls
+ * {@link reExportSinglePatchWithIndexLockRetry} per selected patch.
+ */
+import { getProjectPaths } from '../core/config.js';
+import type { PatchesManifest, PatchMetadata, ReExportOptions } from '../types/commands/index.js';
+import type { FireForgeConfig } from '../types/config.js';
+import type { AdjacentUnmanagedContext } from './re-export-adjacent.js';
+import type { ForeignDriftContext } from './re-export-drift.js';
+import { type ReExportLintContext } from './re-export-lint.js';
+/**
+ * Retries a single patch re-export exactly once when the failure is
+ * transient git `index.lock` contention (an external git process holding
+ * the engine repo's index). The retry re-enters `reExportSinglePatch`
+ * from the top, so it re-reads clean state; a second lock failure
+ * propagates to the loop's honest "N of M" accounting.
+ */
+export declare function reExportSinglePatchWithIndexLockRetry(patch: PatchMetadata, paths: ReturnType<typeof getProjectPaths>, manifest: PatchesManifest, options: ReExportOptions, isDryRun: boolean, config: FireForgeConfig, adjacentCtx: AdjacentUnmanagedContext, driftCtx: ForeignDriftContext, lintCtx: ReExportLintContext): Promise<boolean>;

package/dist/src/commands/re-export-single.js

@@ -0,0 +1,261 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Single-patch refresh core for `fireforge re-export`, split out of
+ * `re-export.ts` (at the per-file line budget after the FORGE J1/J2
+ * hoisted-lint and foreign-drift wiring). The orchestrator loop calls
+ * {@link reExportSinglePatchWithIndexLockRetry} per selected patch.
+ */
+import { getProjectPaths } from '../core/config.js';
+import { enforceFreshFurnaceSources } from '../core/furnace-stale-export.js';
+import { getDiffForFilesAgainstHead } from '../core/git-diff.js';
+import { updatePatchAndMetadata } from '../core/patch-export.js';
+import { buildProjectedManifest, enforcePatchPolicy } from '../core/patch-policy.js';
+import { isGitIndexLockConflict } from '../errors/git.js';
+import { info, success, warn } from '../utils/logger.js';
+import { findMissingFiles, reportAdjacentUnmanagedFiles } from './re-export-adjacent.js';
+import { reportForeignDrift } from './re-export-drift.js';
+import { lintReExportedPatch, refreshQueueCtxEntry, storeReExportLintResult, } from './re-export-lint.js';
+import { assertScanAdoptionsHaveNoForwardImports, assertScanFileAdditionsHaveDiffHunks, confirmBroadScanAdditions, scanPatchFilesForReExport, } from './re-export-scan.js';
+const GIT_INDEX_LOCK_RETRY_MS = 300;
+/**
+ * Retries a single patch re-export exactly once when the failure is
+ * transient git `index.lock` contention (an external git process holding
+ * the engine repo's index). The retry re-enters `reExportSinglePatch`
+ * from the top, so it re-reads clean state; a second lock failure
+ * propagates to the loop's honest "N of M" accounting.
+ */
+export async function reExportSinglePatchWithIndexLockRetry(patch, paths, manifest, options, isDryRun, config, adjacentCtx, driftCtx, lintCtx) {
+    try {
+        return await reExportSinglePatch(patch, paths, manifest, options, isDryRun, config, adjacentCtx, driftCtx, lintCtx);
+    }
+    catch (error) {
+        if (!isGitIndexLockConflict(error)) {
+            throw error;
+        }
+        warn(`${patch.filename}: git index.lock contention detected — retrying once after ${String(GIT_INDEX_LOCK_RETRY_MS)} ms...`);
+        await new Promise((resolve) => setTimeout(resolve, GIT_INDEX_LOCK_RETRY_MS));
+        return await reExportSinglePatch(patch, paths, manifest, options, isDryRun, config, adjacentCtx, driftCtx, lintCtx);
+    }
+}
+async function reExportSinglePatch(patch, paths, manifest, options, isDryRun, config, adjacentCtx, driftCtx, lintCtx) {
+    let currentFilesAffected = [...patch.filesAffected];
+    // --- Scan for new/removed files ---
+    if (options.scan) {
+        const scanResult = await scanPatchFilesForReExport({
+            currentFilesAffected,
+            engineDir: paths.engine,
+            manifest,
+            patchFilename: patch.filename,
+            isDryRun,
+            ...(options.scanFiles !== undefined ? { scanFiles: options.scanFiles } : {}),
+        });
+        // Forward-import gate at adoption time (runs in dry-run too): refuse
+        // to adopt unmanaged files that import modules created by LATER
+        // patches — the after-the-fact lint failure this leaves behind is the
+        // field-reported footgun. Applies to broad --scan, --scan-file, and
+        // the --scan-files bulk assignments alike.
+        await assertScanAdoptionsHaveNoForwardImports({
+            patchesDir: paths.patches,
+            engineDir: paths.engine,
+            patchFilename: patch.filename,
+            added: scanResult.added,
+        });
+        if (options.scanFiles === undefined) {
+            const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
+            const proceed = await confirmBroadScanAdditions({
+                patchFilename: patch.filename,
+                added: scanResult.added,
+                isDryRun,
+                yes: options.yes === true,
+                isInteractive,
+            });
+            if (!proceed) {
+                return false;
+            }
+        }
+        currentFilesAffected = scanResult.updated;
+    }
+    else if (options.files === undefined) {
+        // Finding #16: when neither `--scan` nor `--files` is set and some
+        // of the manifest's claimed files no longer exist on disk, the
+        // re-export silently writes a refreshed body whose filesAffected
+        // still names the vanished paths. That is the documented contract,
+        // but it is also a footgun — a later `verify` then fails on
+        // manifest-consistency with no obvious trigger. Emit one advisory
+        // warning up-front when we can detect the drift cheaply, so the
+        // operator has a chance to re-run with `--scan` or `--files`
+        // before the stale filesAffected lands in patches.json.
+        const args = { patch, paths, manifest, currentFilesAffected, ctx: adjacentCtx };
+        if (await reportAdjacentUnmanagedFiles(args))
+            return false;
+    }
+    // --- Explicit file-subset path ---
+    // When --files is given, the target filesAffected is authoritative — drop
+    // anything not in the list, add anything new. This is the surgical repair
+    // primitive that replaces hand-editing patches.json; the user has already
+    // acknowledged via confirmDestructive (done in the caller) that any drop
+    // is intentional.
+    if (options.files !== undefined) {
+        const requested = [...new Set(options.files)].sort();
+        currentFilesAffected = requested;
+        const removed = patch.filesAffected.filter((f) => !requested.includes(f));
+        const added = requested.filter((f) => !patch.filesAffected.includes(f));
+        for (const f of added)
+            info(`  + ${f}`);
+        for (const f of removed)
+            info(`  - ${f}`);
+    }
+    // Stale-furnace-source gate (0.37.0 item 4): re-export captures deployed
+    // engine copies, so a component source edited after the last furnace
+    // apply would land in the patch as its OLD deployed content. Refuse (or
+    // warn under --allow-stale-furnace) before diffing. Runs in dry-run too
+    // so the failure surfaces early.
+    await enforceFreshFurnaceSources(paths.root, currentFilesAffected, options.allowStaleFurnace === true, 're-export');
+    const missingFiles = await findMissingFiles(paths.engine, currentFilesAffected);
+    if (missingFiles.length === currentFilesAffected.length) {
+        warn(`Skipped ${patch.filename}: all affected files missing`);
+        warn(`Missing files: ${missingFiles.join(', ')}`);
+        return false;
+    }
+    if (missingFiles.length > 0) {
+        warn(`${patch.filename}: missing files will be skipped: ${missingFiles.join(', ')}`);
+    }
+    const missingSet = new Set(missingFiles);
+    const existingFiles = currentFilesAffected.filter((f) => !missingSet.has(f));
+    const diffContent = await getDiffForFilesAgainstHead(paths.engine, existingFiles);
+    assertScanFileAdditionsHaveDiffHunks({
+        diffContent,
+        patchFilename: patch.filename,
+        previousFilesAffected: patch.filesAffected,
+        scanFiles: options.scanFiles,
+    });
+    if (!diffContent.trim()) {
+        warn(`Skipped ${patch.filename}: no changes (files unchanged from HEAD)`);
+        return false;
+    }
+    // Foreign-drift preview + optional hard stop (FORGE J2): show which
+    // payload lines are about to enter the body that the old body did not
+    // carry — the case where a concurrent session's uncommitted edits in
+    // OWNED files would be silently absorbed. Always previews (including
+    // dry-run and --scan); refuses only under --refuse-foreign-drift.
+    if (await reportForeignDrift({
+        patch,
+        patchesDir: paths.patches,
+        newDiffContent: diffContent,
+        ctx: driftCtx,
+    })) {
+        return false;
+    }
+    const { updates, ignoreChecks, effectiveTier, existingIgnoreSet, flagIgnoreSet } = computeReExportUpdates(patch, options, currentFilesAffected);
+    enforcePatchPolicy({
+        config,
+        manifest: buildProjectedManifest(manifest, manifest.patches.map((entry) => entry.filename === patch.filename ? { ...entry, ...updates } : entry)),
+        command: 're-export',
+        forceUnsafe: options.forceUnsafe === true,
+    });
+    // Lint against the ONCE-per-invocation hoisted context (queue context +
+    // queue-wide checkJs program + per-patch result cache) instead of
+    // rebuilding ~37 s of setup for every patch in the loop (FORGE J1).
+    const projectedMetadata = { ...patch, ...updates };
+    const lintResult = await lintReExportedPatch({
+        lintCtx,
+        patch,
+        projectedMetadata,
+        existingFiles,
+        diffContent,
+        ...(options.skipLint !== undefined ? { skipLint: options.skipLint } : {}),
+        ...(ignoreChecks !== undefined ? { ignoreChecks } : {}),
+        ...(effectiveTier !== undefined ? { patchTier: effectiveTier } : {}),
+    });
+    if (isDryRun) {
+        info(`[dry-run] ${patch.filename}: ${existingFiles.length} file(s)`);
+        if (effectiveTier !== undefined && effectiveTier !== patch.tier) {
+            info(`[dry-run] ${patch.filename}: tier would become ${effectiveTier}`);
+        }
+        const addedIgnores = [...flagIgnoreSet].filter((id) => !existingIgnoreSet.has(id));
+        if (addedIgnores.length > 0) {
+            info(`[dry-run] ${patch.filename}: lintIgnore would gain ${addedIgnores.join(', ')}`);
+        }
+    }
+    else {
+        await commitRefreshedPatch({
+            patch,
+            paths,
+            manifest,
+            options,
+            config,
+            lintCtx,
+            diffContent,
+            updates,
+            projectedMetadata,
+            existingFiles,
+            lintResult,
+        });
+    }
+    return true;
+}
+/**
+ * Writes the refreshed body + manifest row atomically under the patch
+ * directory lock (a split write would let a concurrent queue mutation
+ * leave body and `filesAffected` disagreeing), then keeps the run's
+ * in-memory state honest: the queue context entry is refreshed and the
+ * fresh lint result is stored keyed against the just-written body — the
+ * state a repeat invocation will observe (FORGE J1) — and the in-memory
+ * manifest row mirrors the on-disk write for later loop iterations
+ * (notably `--all --scan`, where `getClaimedFiles` reads this manifest).
+ */
+async function commitRefreshedPatch(args) {
+    const { patch, paths, manifest, options, config, lintCtx, diffContent, updates } = args;
+    await updatePatchAndMetadata(paths.patches, patch.filename, diffContent, updates, undefined, {
+        config,
+        command: 're-export',
+        forceUnsafe: options.forceUnsafe === true,
+    });
+    refreshQueueCtxEntry(lintCtx, patch.filename, diffContent);
+    if (args.lintResult !== null) {
+        await storeReExportLintResult(lintCtx, patch.filename, args.projectedMetadata, args.existingFiles, args.lintResult);
+    }
+    const patchIndex = manifest.patches.findIndex((pm) => pm.filename === patch.filename);
+    if (patchIndex !== -1) {
+        const existingEntry = manifest.patches[patchIndex];
+        if (existingEntry) {
+            manifest.patches[patchIndex] = {
+                ...existingEntry,
+                ...updates,
+            };
+        }
+    }
+    success(`Re-exported ${patch.filename}`);
+}
+/**
+ * Threads the patch's own `lintIgnore` list through so the per-patch
+ * suppression honoured by export/export-all is also honoured here — a
+ * re-export could otherwise not refresh an advisory-noisy but intentional
+ * patch without the blunt `--skip-lint`. The paired `patch.tier` threads
+ * the explicit branding-threshold opt-in the same way. The CLI flags
+ * `--tier` and `--lint-ignore` participate with append/union semantics
+ * (explicit removal lives on `fireforge patch lint-ignore`), computed
+ * before the lint pass so the new intent takes effect on this invocation.
+ */
+function computeReExportUpdates(patch, options, currentFilesAffected) {
+    const existingIgnoreSet = new Set(patch.lintIgnore ?? []);
+    const flagIgnoreSet = new Set(options.lintIgnore ?? []);
+    const mergedIgnoreSet = new Set([...existingIgnoreSet, ...flagIgnoreSet]);
+    const effectiveLintIgnore = mergedIgnoreSet.size > 0 ? [...mergedIgnoreSet] : undefined;
+    const updates = {
+        filesAffected: currentFilesAffected,
+    };
+    if (options.tier !== undefined) {
+        updates.tier = options.tier;
+    }
+    if (effectiveLintIgnore !== undefined && flagIgnoreSet.size > 0) {
+        updates.lintIgnore = effectiveLintIgnore;
+    }
+    return {
+        updates,
+        ignoreChecks: effectiveLintIgnore ? new Set(effectiveLintIgnore) : undefined,
+        effectiveTier: options.tier ?? patch.tier,
+        existingIgnoreSet,
+        flagIgnoreSet,
+    };
+}

package/dist/src/commands/re-export.d.ts

@@ -1,5 +1,3 @@
-import { Command } from 'commander';
-import type { CommandContext } from '../types/cli.js';
 import type { ReExportOptions } from '../types/commands/index.js';
 /**
  * Runs the re-export command to regenerate existing patches from current engine state.
@@ -8,5 +6,3 @@ import type { ReExportOptions } from '../types/commands/index.js';
  * @param options - Re-export options
  */
 export declare function reExportCommand(projectRoot: string, patches: string[], options: ReExportOptions): Promise<void>;
-/** Registers the re-export command on the CLI program. */
-export declare function registerReExport(program: Command, { getProjectRoot, withErrorHandling }: CommandContext): void;