@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/commands/discard.js

@@ -1,216 +1,39 @@
 // SPDX-License-Identifier: EUPL-1.2
-import { confirm } from '@clack/prompts';
-import { Command } from 'commander';
-import { getProjectPaths } from '../core/config.js';
-import { stdioIsInteractive } from '../core/destructive.js';
-import { applyDiscardBaseline, describeConflictWarning, describeDiscardBaseline, describeDiscardOutcome, planDiscardBaselines, planUpstreamDiscards, summarizeDiscardBaselines, } from '../core/discard-baseline.js';
-import { assertEngineGitReady } from '../core/engine-precondition.js';
-import { collectFurnaceManagedPrefixes } from '../core/furnace-config.js';
-import { expandUntrackedDirectoryEntries, getWorkingTreeStatus } from '../core/git-status.js';
-import { GeneralError, InvalidArgumentError } from '../errors/base.js';
-import { GitError } from '../errors/git.js';
-import { toError } from '../utils/errors.js';
-import { info, intro, isCancel, outro, spinner, warn } from '../utils/logger.js';
-import { pickDefined } from '../utils/options.js';
-/**
- * Shared interactive confirmation for the single-file and directory paths.
- * Returns false when the operator cancelled (the caller printed the outro).
- */
-async function confirmDiscard(message, hint, options) {
-    if (options.yes || options.dryRun)
-        return true;
-    const isInteractive = stdioIsInteractive();
-    if (!isInteractive) {
-        throw new InvalidArgumentError('Interactive confirmation not available. Use --yes flag to discard without confirmation.', hint);
-    }
-    const confirmed = await confirm({ message, initialValue: false });
-    if (isCancel(confirmed) || !confirmed) {
-        outro('Discard cancelled');
-        return false;
-    }
-    return true;
-}
-/**
- * Plans the restore baseline for `entries`: the patch-applied baseline for
- * patch-claimed paths, or pristine HEAD when `--to-upstream`
- * explicitly requests it.
- */
-async function planDiscards(patchesDir, engineDir, entries, options) {
-    if (options.toUpstream)
-        return planUpstreamDiscards(entries);
-    return planDiscardBaselines(patchesDir, engineDir, entries);
-}
-/** Dry-run label including the rename pair and the restore-baseline suffix. */
-function dryRunLabel(plan) {
-    const { entry } = plan;
-    const target = entry.originalPath && entry.originalPath !== entry.file
-        ? `${entry.originalPath} -> ${entry.file}`
-        : entry.file;
-    return `${target} (${describeDiscardBaseline(plan)})`;
-}
-/**
- * Discards every status entry whose path lives under `dirPath`. Used by
- * `discardCommand` as a directory-recursion fallback when the operator
- * passed a directory path that contains modified or untracked entries
- * but is not itself a status entry.
- *
- * Mirrors the single-file path's confirmation, dry-run, and Furnace-aware
- * warning behaviour so the contract stays consistent. Each per-entry
- * discard runs sequentially under its own try/catch so a failure on one
- * file is reported but does not block the remaining files in the batch.
- */
-async function discardDirectoryEntries(projectRoot, engineDir, patchesDir, dirPath, entries, options) {
-    const proceed = await confirmDiscard(`Discard changes to ${entries.length} file${entries.length === 1 ? '' : 's'} under ${dirPath}/?`, 'Use: fireforge discard <directory> --yes', options);
-    if (!proceed)
-        return;
-    const plans = await planDiscards(patchesDir, engineDir, entries, options);
-    if (options.dryRun) {
-        info(`Would discard changes to ${entries.length} file(s) under ${dirPath}/:`);
-        for (const plan of plans) {
-            info(`  ${dryRunLabel(plan)}`);
-        }
-        outro('Dry run complete — no changes made');
-        return;
-    }
-    const s = spinner(`Discarding ${entries.length} file(s) under ${dirPath}/...`);
-    let succeeded = 0;
-    const failures = [];
-    const appliedPlans = [];
-    try {
-        for (const plan of plans) {
-            try {
-                await applyDiscardBaseline(engineDir, plan);
-                appliedPlans.push(plan);
-                succeeded += 1;
-            }
-            catch (error) {
-                failures.push(`${plan.entry.file}: ${toError(error).message}`);
-            }
-        }
-        s.stop(`Discarded ${succeeded} of ${entries.length} file(s) under ${dirPath}/${failures.length > 0 ? ` (${failures.length} failed)` : ''}`);
-        for (const failure of failures) {
-            warn(`  ${failure}`);
-        }
-        for (const plan of appliedPlans) {
-            if (plan.conflicted)
-                warn(describeConflictWarning(plan));
-        }
-        try {
-            const furnacePrefixes = await collectFurnaceManagedPrefixes(projectRoot);
-            const dirIsFurnace = [...furnacePrefixes].some((prefix) => `${dirPath}/`.startsWith(prefix) || prefix.startsWith(`${dirPath}/`));
-            if (dirIsFurnace) {
-                warn('These paths are managed by Furnace. Run "fireforge furnace apply" to redeploy components if needed.');
-            }
-        }
-        catch {
-            // Furnace config may not exist, so skip silently.
-        }
-        if (failures.length > 0) {
-            throw new GeneralError(`Failed to discard ${failures.length} file(s) under ${dirPath}/. See warnings above.`);
-        }
-        outro(summarizeDiscardBaselines(appliedPlans, succeeded));
-    }
-    catch (error) {
-        if (!(error instanceof GeneralError)) {
-            s.error('Discard failed');
-        }
-        throw error;
-    }
-}
-/**
- * Runs the discard command to revert changes to a specific file.
- * @param projectRoot - Root directory of the project
- * @param file - File path to discard (relative to engine/)
- * @param options - Discard options
- */
-export async function discardCommand(projectRoot, file, options = {}) {
-    intro('FireForge Discard');
-    const paths = getProjectPaths(projectRoot);
-    await assertEngineGitReady(paths.engine);
-    // Check if the file has changes
-    const statusEntries = await expandUntrackedDirectoryEntries(paths.engine, await getWorkingTreeStatus(paths.engine));
-    const statusEntry = statusEntries.find((entry) => entry.file === file || entry.originalPath === file);
-    // Directory recursion fallback: when the explicit path does not match a
-    // single status entry but does correspond to one or more entries below it,
-    // treat the input as a directory and discard everything inside. Otherwise
-    // `discard <dir> --yes` fails with "no changes to discard" even though
-    // `status --unmanaged` lists files under that directory, forcing the
-    // operator to discard each file individually. Match against the
-    // directory-with-trailing-slash form so a path like `foo/bar` does not
-    // accidentally match `foo/bar2/file`.
-    if (!statusEntry) {
-        // Normalize the operator's input once: `discard foo/` (or `foo//`) must
-        // not produce doubled slashes in the messages and prefix comparisons
-        // below, which all append `/` themselves.
-        const dirPath = file.replace(/\/+$/, '');
-        const dirPrefix = `${dirPath}/`;
-        const dirEntries = statusEntries.filter((entry) => entry.file.startsWith(dirPrefix) || entry.originalPath?.startsWith(dirPrefix));
-        if (dirEntries.length > 0) {
-            await discardDirectoryEntries(projectRoot, paths.engine, paths.patches, dirPath, dirEntries, options);
-            return;
-        }
-        throw new GeneralError(`File "${file}" has no changes to discard.`);
-    }
-    const proceed = await confirmDiscard(`Discard all changes to ${statusEntry.file}?`, 'Use: fireforge discard <file> --yes', options);
-    if (!proceed)
-        return;
-    const [plan] = await planDiscards(paths.patches, paths.engine, [statusEntry], options);
-    if (!plan) {
-        throw new GeneralError(`File "${file}" has no changes to discard.`);
-    }
-    if (options.dryRun) {
-        // Show the rename pair regardless of which side the operator passed.
-        // Discarding the new path of a rename also resurrects the old path, so
-        // the preview names both, exactly when the full picture matters most.
-        info(`Would discard changes to: ${dryRunLabel(plan)}`);
-        outro('Dry run complete — no changes made');
-        return;
-    }
-    const s = spinner(`Discarding changes to ${file}...`);
-    try {
-        await applyDiscardBaseline(paths.engine, plan);
-        s.stop(`Discarded changes to ${file}`);
-        if (plan.conflicted) {
-            warn(describeConflictWarning(plan));
-        }
-        // Warn when the discarded file is managed by Furnace so the user knows
-        // to re-apply if they want the component's deployed state back.
-        try {
-            const furnacePrefixes = await collectFurnaceManagedPrefixes(projectRoot);
-            if ([...furnacePrefixes].some((prefix) => file.startsWith(prefix))) {
-                warn('This file is managed by Furnace. Run "fireforge furnace apply" to restore it.');
-            }
-        }
-        catch {
-            // Furnace config may not exist, so skip silently.
-        }
-        outro(describeDiscardOutcome(plan, options.toUpstream === true));
-    }
-    catch (error) {
-        s.error('Discard failed');
-        if (error instanceof GitError || error instanceof GeneralError) {
-            throw error;
-        }
-        throw new GitError(`Failed to discard ${file}`, plan.kind === 'unmanaged'
-            ? statusEntry.isUntracked
-                ? `rm ${statusEntry.file}`
-                : `restore --source HEAD --staged --worktree -- ${statusEntry.file}`
-            : `write patch baseline for ${statusEntry.file}`, 
-        // Always attach the cause via toError so thrown primitives (strings,
-        // numbers) produced by poorly-behaved utilities still propagate as
-        // an Error, preserving stack traces for verbose-mode triage.
-        toError(error));
-    }
-}
-/** Registers the discard command on the CLI program. */
-export function registerDiscard(program, { getProjectRoot, withErrorHandling }) {
-    program
-        .command('discard <file>')
-        .description('Discard changes to a specific file, restoring patch-claimed paths to their patch-applied baseline (unmanaged untracked files are deleted). Pass a directory path to discard every modified or untracked file beneath it; the operation walks the status output and reverts each match individually.')
-        .option('--dry-run', 'Show what would be discarded without doing it')
-        .option('--to-upstream', 'Restore to pristine upstream (HEAD) instead of the patch-applied baseline; deletes patch-created files')
-        .option('-y, --yes', 'Skip confirmation prompt')
-        .action(withErrorHandling(async (file, options) => {
-        await discardCommand(getProjectRoot(), file, pickDefined(options));
-    }));
-}
+import { arg, defineCommand, lockOptions, lockWaitMs } from '../cli/command.js';
+import { withEngineLock } from '../engine/index.js';
+import { loadProject } from '../project/index.js';
+import { discard as discardPaths, enginePaths, requirePatchMode } from '../queue/index.js';
+export const discard = defineCommand({
+    name: 'discard',
+    summary: 'Restore engine files to what the patch queue leaves there',
+    description: 'A file the queue touches gets the queue-applied content back (re-created or removed as the ' +
+        'queue has it); any other changed file goes back to upstream, and an untracked one is deleted. ' +
+        'Paths are engine-relative (relative to the current directory inside engine/); a directory ' +
+        'covers every changed file below it. A recovery snapshot keeps what is discarded.',
+    group: 'Patches',
+    args: { paths: arg.list('Engine files or directories', { required: true }) },
+    options: { ...lockOptions },
+    json: true,
+    run: async (ctx, { paths }, opts) => {
+        const project = requirePatchMode(await loadProject(ctx.cwd, ctx.env));
+        const targets = enginePaths(project.paths.engine, ctx.cwd, paths);
+        const result = await withEngineLock(project, { command: 'discard', waitMs: lockWaitMs(opts.waitLock) }, () => discardPaths(project, targets));
+        if (result.paths.length === 0)
+            ctx.out.line('Nothing to discard.');
+        for (const entry of result.paths) {
+            const to = entry.to === 'queue' ? `queue baseline (${entry.owners.join(', ')})` : 'upstream';
+            ctx.out.line(`${entry.path}: ${entry.was} -> ${to}`);
+        }
+        if (result.snapshot !== undefined)
+            ctx.out.line(`Recovery snapshot: ${result.snapshot}`);
+        ctx.out.json({
+            paths: result.paths.map((entry) => ({
+                path: entry.path,
+                was: entry.was,
+                to: entry.to,
+                owners: [...entry.owners],
+            })),
+            snapshot: result.snapshot ?? null,
+        });
+    },
+});