@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/commands/patch/lint-ignore-from.js

@@ -1,141 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Batch and per-entry input for `patch lint-ignore --add`. Split out of
- * `lint-ignore.ts` for the per-file line budget.
- *
- * `--max` applies to every `--add` of a call, so a rebaseline that sets a
- * ceiling per rule would take one call per rule, each taking the patch lock
- * and rewriting `patches.json`. Two forms avoid that:
- *
- * - `--add <rule>=<max>` gives each entry its own ceiling in one call.
- * - `--from <json-file>` reads every entry from a file, under one lock hold
- *   and one write. The file is a JSON array of entries (a check ID string,
- *   or `{ rule, max, reason?, share?, meta?, patch? }`), or a
- *   `lint --per-patch --report` document, whose `lintIgnoreCeilings` rows
- *   for the target patch are rebaselined to their current measurement.
- */
-import { LINT_IGNORE_CEILING_RULES, parseLintIgnoreEntries } from '../../core/patch-lint-ignore.js';
-import { InvalidArgumentError } from '../../errors/base.js';
-import { toError } from '../../utils/errors.js';
-import { readJson } from '../../utils/fs.js';
-import { isArray, isObject } from '../../utils/validation.js';
-const RULE_MAX_PATTERN = /^(?<rule>[^=\s]+)=(?<max>[1-9]\d*)$/;
-/**
- * Turns `--add` values into entries: `<rule>=<max>` is a ceiling at `max`,
- * a bare ID is a ceiling at `--max` when that is given and a bare waiver
- * otherwise. Every ceiling takes `--reason` (required) and `--share`.
- *
- * @param ids - The `--add` values
- * @param options - Command options (`max`, `reason`, `share`)
- * @returns The entries to upsert
- */
-export function resolveAddEntries(ids, options) {
-    const parsed = ids.map((id) => {
-        if (id.includes('=')) {
-            const match = RULE_MAX_PATTERN.exec(id);
-            if (match?.groups === undefined) {
-                throw new InvalidArgumentError(`--add ${id}: expected <rule>=<max> with a positive integer max.`, '--add');
-            }
-            return { rule: match.groups['rule'], max: Number(match.groups['max']) };
-        }
-        return { rule: id, max: options.max };
-    });
-    const ceilings = parsed.filter((entry) => entry.max !== undefined);
-    if (ceilings.length === 0) {
-        if (options.reason !== undefined || options.share !== undefined) {
-            throw new InvalidArgumentError('--reason and --share apply to ceilings: pass --max <n> or --add <rule>=<max>.', options.reason !== undefined ? '--reason' : '--share');
-        }
-        return parsed.map((entry) => entry.rule);
-    }
-    if (options.reason === undefined || options.reason.trim() === '') {
-        throw new InvalidArgumentError('A lintIgnore ceiling needs --reason <text> (with --max <n> or --add <rule>=<max>).', '--reason');
-    }
-    const unmeasured = ceilings.filter((entry) => !LINT_IGNORE_CEILING_RULES.includes(entry.rule));
-    if (unmeasured.length > 0) {
-        throw new InvalidArgumentError(`A ceiling only applies to the measured size rules (${LINT_IGNORE_CEILING_RULES.join(', ')}); ` +
-            `got ${unmeasured.map((entry) => entry.rule).join(', ')}.`, '--max');
-    }
-    const { reason, share } = options;
-    return validated(parsed.map((entry) => entry.max === undefined
-        ? entry.rule
-        : { rule: entry.rule, max: entry.max, reason, ...(share !== undefined ? { share } : {}) }), '--add');
-}
-/** Runs the manifest validator over CLI-built entries, as an argument error. */
-function validated(entries, flag) {
-    try {
-        return parseLintIgnoreEntries(entries, flag);
-    }
-    catch (error) {
-        throw new InvalidArgumentError(toError(error).message, flag);
-    }
-}
-/** The target patch's ceiling rows of a lint report, rebaselined to their measurement. */
-function rebaselineFromReport(data, targetFilename) {
-    const patches = isArray(data['patches']) ? data['patches'] : [];
-    const row = patches.find((patch) => isObject(patch) && patch['filename'] === targetFilename);
-    const ceilings = isObject(row) && isArray(row['lintIgnoreCeilings']) ? row['lintIgnoreCeilings'] : [];
-    const raw = [];
-    for (const ceiling of ceilings) {
-        if (!isObject(ceiling) || typeof ceiling['measurement'] !== 'number')
-            continue;
-        if (ceiling['measurement'] <= 0)
-            continue;
-        const { measurement, rule, reason, share, meta } = ceiling;
-        raw.push({
-            rule,
-            max: measurement,
-            reason,
-            ...(share !== undefined ? { share } : {}),
-            ...(meta !== undefined ? { meta } : {}),
-        });
-    }
-    return { raw, skipped: patches.length - (row === undefined ? 0 : 1) };
-}
-/**
- * Reads a `--from` file into entries for `targetFilename`.
- *
- * @param path - JSON file path
- * @param targetFilename - The patch the command edits
- * @param defaultReason - `--reason`, used for object entries without one
- * @returns The validated entries and the count left out for other patches
- */
-export async function readLintIgnoreBatch(path, targetFilename, defaultReason) {
-    let data;
-    try {
-        data = await readJson(path);
-    }
-    catch (error) {
-        throw new InvalidArgumentError(`Cannot read --from ${path}: ${toError(error).message}`, '--from');
-    }
-    if (isObject(data)) {
-        const { raw, skipped } = rebaselineFromReport(data, targetFilename);
-        return { entries: validated(raw, '--from'), skippedForOtherPatches: skipped };
-    }
-    if (!isArray(data)) {
-        throw new InvalidArgumentError('--from must hold a JSON array of lintIgnore entries or a "lint --per-patch --report" document.', '--from');
-    }
-    const raw = [];
-    let skipped = 0;
-    for (const entry of data) {
-        if (!isObject(entry)) {
-            raw.push(entry);
-            continue;
-        }
-        const { patch, ...rest } = entry;
-        if (patch !== undefined && patch !== targetFilename) {
-            skipped++;
-            continue;
-        }
-        raw.push(rest['reason'] === undefined && defaultReason !== undefined
-            ? { ...rest, reason: defaultReason }
-            : rest);
-    }
-    return { entries: validated(raw, '--from'), skippedForOtherPatches: skipped };
-}
-/** Parses `--share`. */
-export function parseShare(value) {
-    if (value !== 'test' && value !== 'product') {
-        throw new InvalidArgumentError(`--share must be "test" or "product" (got "${value}").`, '--share');
-    }
-    return value;
-}

package/dist/src/commands/patch/lint-ignore.d.ts

@@ -1,42 +0,0 @@
-/**
- * `fireforge patch lint-ignore <name>`: adds, removes, or clears entries
- * in `PatchMetadata.lintIgnore` without rewriting the `.patch` file body.
- *
- * Companion to `fireforge re-export <name> --lint-ignore <id>` (which is
- * append-only). It exists for the cases re-export cannot express:
- * - Removing a single entry without dropping the rest of the list.
- * - Clearing the entire list when the operator wants the rule(s) to
- *   start firing again.
- * - Editing metadata when the patch body is already correct, so the
- *   re-export's engine read + diff regeneration roundtrip is wasted.
- *
- * Modes are mutually exclusive: exactly one of `--add`, `--remove`, or
- * `--clear` must be supplied per invocation. `--add <rule> --max <n>
- * --reason <text>` writes a size waiver with a ceiling (see
- * `core/patch-lint-ignore.ts`) instead of a bare check ID; an `--add` for a
- * rule that already has an entry replaces it, so the same command moves a
- * ceiling or widens it back to a bare waiver. The read-modify-write
- * happens inside the patch directory lock via {@link mutatePatchMetadata}
- * so a concurrent writer cannot interleave between the read and the
- * write, which matters when an operator scripts repeated invocations or
- * runs `--add` and `--remove` back-to-back.
- */
-import { Command } from 'commander';
-import type { CommandContext } from '../../types/cli.js';
-import type { PatchLintIgnoreOptions } from '../../types/commands/index.js';
-/**
- * Runs the `patch lint-ignore` command: reads the patch's existing
- * `lintIgnore`, applies the requested mode, and writes the manifest.
- *
- * @param projectRoot - Project root directory
- * @param identifier - Patch filename, ordinal, or manifest `name`
- * @param options - Command options (exactly one of `add`/`remove`/`clear`)
- */
-export declare function patchLintIgnoreCommand(projectRoot: string, identifier: string, options?: PatchLintIgnoreOptions): Promise<void>;
-/**
- * Registers the `patch lint-ignore` subcommand on the `patch` parent.
- *
- * @param parent - Parent Commander command
- * @param context - Shared CLI registration context
- */
-export declare function registerPatchLintIgnore(parent: Command, context: CommandContext): void;

package/dist/src/commands/patch/lint-ignore.js

@@ -1,263 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * `fireforge patch lint-ignore <name>`: adds, removes, or clears entries
- * in `PatchMetadata.lintIgnore` without rewriting the `.patch` file body.
- *
- * Companion to `fireforge re-export <name> --lint-ignore <id>` (which is
- * append-only). It exists for the cases re-export cannot express:
- * - Removing a single entry without dropping the rest of the list.
- * - Clearing the entire list when the operator wants the rule(s) to
- *   start firing again.
- * - Editing metadata when the patch body is already correct, so the
- *   re-export's engine read + diff regeneration roundtrip is wasted.
- *
- * Modes are mutually exclusive: exactly one of `--add`, `--remove`, or
- * `--clear` must be supplied per invocation. `--add <rule> --max <n>
- * --reason <text>` writes a size waiver with a ceiling (see
- * `core/patch-lint-ignore.ts`) instead of a bare check ID; an `--add` for a
- * rule that already has an entry replaces it, so the same command moves a
- * ceiling or widens it back to a bare waiver. The read-modify-write
- * happens inside the patch directory lock via {@link mutatePatchMetadata}
- * so a concurrent writer cannot interleave between the read and the
- * write, which matters when an operator scripts repeated invocations or
- * runs `--add` and `--remove` back-to-back.
- */
-import { Command, Option } from 'commander';
-import { confirmDestructive } from '../../core/destructive.js';
-import { appendHistoryBestEffort } from '../../core/history-log.js';
-import { mutatePatchMetadata } from '../../core/patch-export.js';
-import { addedLintIgnoreEntries, formatLintIgnoreEntry, formatLintIgnoreList, lintIgnoreRule, removeLintIgnoreRules, upsertLintIgnoreEntries, } from '../../core/patch-lint-ignore.js';
-import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
-import { info, intro, outro, warn } from '../../utils/logger.js';
-import { addWaitLockOption, commanderArgParser, resolveWaitLockSeconds, stringListOption, } from '../../utils/options.js';
-import { parsePositiveIntegerFlag } from '../../utils/validation.js';
-import { proceedAfterDecision } from '../destructive-decision.js';
-import { parseShare, readLintIgnoreBatch, resolveAddEntries } from './lint-ignore-from.js';
-import { requirePatchQueue, requirePatchTarget } from './patch-context.js';
-/**
- * Printed whenever `--add` lands a new check id. The waiver this command
- * writes turns per-patch lint green immediately, but consumer projects
- * commonly audit lintIgnore lists against a reviewed allow-map, and
- * discovering that the map also needs updating otherwise costs a full
- * downstream gate run.
- */
-const LINT_IGNORE_REVIEW_WARNING = "This lint waiver is subject to the project's patch-policy review process. " +
-    'Downstream policy audits that mirror lintIgnore lists in a reviewed allow-map ' +
-    'will refuse this patch until the map is updated to include the new ID(s).';
-/**
- * Computes the post-mutation `lintIgnore` list for a given mode.
- * Returns `undefined` when the result should drop the field from the
- * manifest entirely (matching the validator's "preserve only when
- * present" contract).
- */
-function applyMode(existing, mode, values) {
-    if (mode === 'add')
-        return upsertLintIgnoreEntries(existing, values);
-    if (mode === 'remove')
-        return removeLintIgnoreRules(existing, values.map(lintIgnoreRule));
-    // mode === 'clear'
-    return undefined;
-}
-/**
- * Renders a one-line summary of the planned change for use in
- * `info()` / dry-run / history args. Exported for unit-testing the
- * message format directly without mocking the logger transport.
- */
-function describeChange(before, after, mode, values) {
-    if (mode === 'clear') {
-        return before.length === 0
-            ? 'lintIgnore was already empty — no change'
-            : `lintIgnore cleared (was ${formatLintIgnoreList(before)})`;
-    }
-    const currentLabel = before.length > 0 ? `[${formatLintIgnoreList(before)}]` : '(empty)';
-    if (mode === 'add') {
-        const added = addedLintIgnoreEntries(before, after);
-        if (added.length === 0) {
-            // Surface the existing list so a no-op `--add` does not require a
-            // follow-up `patches.json` read to confirm what was already present.
-            return `lintIgnore unchanged (current: ${currentLabel}; all requested IDs already present)`;
-        }
-        return `lintIgnore += ${formatLintIgnoreList(added)} → ${formatLintIgnoreList(after)}`;
-    }
-    // mode === 'remove'
-    const requested = new Set(values.map(lintIgnoreRule));
-    const removed = before.filter((entry) => requested.has(lintIgnoreRule(entry)));
-    if (removed.length === 0) {
-        return `lintIgnore unchanged (current: ${currentLabel}; none of the requested IDs were present)`;
-    }
-    return `lintIgnore −= ${formatLintIgnoreList(removed)} → ${formatLintIgnoreList(after)}`;
-}
-/**
- * Turns the mode's IDs into manifest entries, applying `--max`/`--reason`
- * and `<rule>=<max>` to `--add` (see `lint-ignore-from.ts`). Refuses a
- * ceiling flag without `--add`, a ceiling without a `--reason`, and a
- * ceiling on a rule that carries no measurement, so a waiver that could
- * never suppress anything is not written. A `--from` add resolves later,
- * once the target patch is known.
- */
-function resolveRequestedEntries(mode, options) {
-    const ceilingFlag = options.max !== undefined ? '--max' : options.share !== undefined ? '--share' : undefined;
-    if ((ceilingFlag !== undefined || options.reason !== undefined) && mode !== 'add') {
-        throw new InvalidArgumentError('--max, --reason and --share only apply to --add.', ceilingFlag ?? '--reason');
-    }
-    if (mode === 'remove')
-        return [...(options.remove ?? [])];
-    if (mode !== 'add')
-        return [];
-    if (options.from !== undefined) {
-        if ((options.add?.length ?? 0) > 0 || ceilingFlag !== undefined) {
-            throw new InvalidArgumentError('--from takes its entries from the file; it combines only with --reason (the default reason).', (options.add?.length ?? 0) > 0 ? '--add' : ceilingFlag);
-        }
-        return [];
-    }
-    return resolveAddEntries(options.add ?? [], options);
-}
-/**
- * Runs the `patch lint-ignore` command: reads the patch's existing
- * `lintIgnore`, applies the requested mode, and writes the manifest.
- *
- * @param projectRoot - Project root directory
- * @param identifier - Patch filename, ordinal, or manifest `name`
- * @param options - Command options (exactly one of `add`/`remove`/`clear`)
- */
-export async function patchLintIgnoreCommand(projectRoot, identifier, options = {}) {
-    const isDryRun = options.dryRun === true;
-    intro(isDryRun ? 'FireForge patch lint-ignore (dry run)' : 'FireForge patch lint-ignore');
-    // Mode mutex: exactly one mode per invocation. Combinations like
-    // `--add foo --remove bar` are rejected: an operator who needs both
-    // runs the command twice (clearer audit trail), and `--clear` plus a
-    // mode is contradictory.
-    const adding = (options.add?.length ?? 0) > 0 || options.from !== undefined;
-    const removing = (options.remove?.length ?? 0) > 0;
-    const clearing = options.clear === true;
-    const modeCount = [adding, removing, clearing].filter(Boolean).length;
-    if (modeCount > 1) {
-        throw new InvalidArgumentError('--add, --remove, and --clear are mutually exclusive. Pick one mode per invocation.', 'patch lint-ignore');
-    }
-    if (modeCount === 0) {
-        throw new InvalidArgumentError('Specify --add <id>, --from <json-file>, --remove <id>, or --clear.', 'patch lint-ignore');
-    }
-    const mode = adding ? 'add' : removing ? 'remove' : 'clear';
-    let values = resolveRequestedEntries(mode, options);
-    const { paths, manifest } = await requirePatchQueue(projectRoot);
-    const target = requirePatchTarget(identifier, manifest.patches);
-    if (options.from !== undefined) {
-        const batch = await readLintIgnoreBatch(options.from, target.filename, options.reason);
-        if (batch.skippedForOtherPatches > 0) {
-            info(`--from: ${batch.skippedForOtherPatches} entry/entries for other patches left out.`);
-        }
-        if (batch.entries.length === 0) {
-            throw new InvalidArgumentError(`--from ${options.from} holds no lintIgnore entry for ${target.filename}.`, '--from');
-        }
-        values = batch.entries;
-    }
-    // Destructive-operation contract (docs/lifecycle-invariants.md): manifest
-    // metadata mutations get summary + dry-run + confirmation/--yes + history
-    // uniformly. Accepting --yes without ever prompting makes the flag appear
-    // only in the history record, and suppressing lint findings is the kind
-    // of mutation an operator should approve consciously.
-    const currentList = target.lintIgnore ?? [];
-    const projectedList = applyMode(currentList, mode, values) ?? [];
-    const addsNewIds = mode === 'add' && addedLintIgnoreEntries(currentList, projectedList).length > 0;
-    const projectedSummary = describeChange(currentList, projectedList, mode, values);
-    const decision = await confirmDestructive({
-        operation: 'patch-lint-ignore',
-        title: `Patch lint-ignore: ${target.filename}`,
-        summary: [`${target.filename}: ${projectedSummary}`],
-        yes: options.yes === true,
-        dryRun: isDryRun,
-    });
-    if (decision === 'dry-run' && addsNewIds) {
-        warn(LINT_IGNORE_REVIEW_WARNING);
-    }
-    if (!proceedAfterDecision(decision, 'Cancelled — no changes made'))
-        return;
-    const result = await mutatePatchMetadata(paths.patches, target.filename, (existing) => {
-        const next = applyMode(existing.lintIgnore ?? [], mode, values);
-        // Either set the new list when non-empty or unset the field
-        // entirely. The mutation API splits these to keep the
-        // exactOptionalPropertyTypes contract clean: only set values land
-        // in the typed `Partial<PatchMetadata>`, and the unset list is
-        // applied via `delete` after spread.
-        return next !== undefined ? { set: { lintIgnore: next } } : { unset: ['lintIgnore'] };
-    }, { waitLockSeconds: resolveWaitLockSeconds(options.waitLock), command: 'patch lint-ignore' });
-    if (!result) {
-        // Race: target vanished between the manifest read above and the
-        // locked mutate. Surfaced as a hard error rather than a silent
-        // no-op, because the operator's intent did not land.
-        throw new GeneralError(`Patch ${target.filename} disappeared from the manifest during the update. Re-run after investigating.`);
-    }
-    const existing = result.before.lintIgnore ?? [];
-    const projected = result.after.lintIgnore ?? [];
-    info(`${target.filename}: ${describeChange(existing, projected, mode, values)}.`);
-    if (mode === 'add' && addedLintIgnoreEntries(existing, projected).length > 0) {
-        warn(LINT_IGNORE_REVIEW_WARNING);
-    }
-    await appendHistoryBestEffort(paths.patches, {
-        operation: 'patch-lint-ignore',
-        args: {
-            filename: target.filename,
-            mode,
-            values: values.map(formatLintIgnoreEntry),
-            before: existing,
-            after: projected,
-        },
-        ...(options.yes === true ? { yes: true } : {}),
-        result: 'ok',
-    }, `patch lint-ignore committed (${target.filename})`);
-    outro('Patch lint-ignore complete');
-}
-/**
- * Registers the `patch lint-ignore` subcommand on the `patch` parent.
- *
- * @param parent - Parent Commander command
- * @param context - Shared CLI registration context
- */
-export function registerPatchLintIgnore(parent, context) {
-    const { getProjectRoot, withErrorHandling } = context;
-    const command = parent
-        .command('lint-ignore <name>')
-        .description('Edit PatchMetadata.lintIgnore on a single patch (no .patch body rewrite). One mode per invocation.')
-        .option('--add <check-id>', 'Lint check ID to add to the patch lintIgnore list (repeatable); <rule>=<max> adds a ceiling at <max>. ' +
-        'Needs --yes when not run from a terminal', ...stringListOption())
-        .option('--remove <check-id>', 'Lint check ID to remove from the patch lintIgnore list (repeatable)', ...stringListOption())
-        .option('--clear', 'Drop the lintIgnore field entirely')
-        .addOption(new Option('--max <n>', 'With --add: write a size waiver with a ceiling, suppressing the rule only while its ' +
-        'measurement is at most <n> (file-too-large, large-patch-lines, large-patch-files)').argParser(commanderArgParser((v) => parsePositiveIntegerFlag('--max', v))))
-        .option('--reason <text>', 'Why the ceiling exists (required with --max or <rule>=<max>; with --from: the default for entries without one)')
-        .addOption(new Option('--share <share>', 'With a large-patch-lines ceiling: bound only the "product" or "test" share of the measurement').argParser(commanderArgParser(parseShare)))
-        .option('--from <json-file>', 'Add every entry in a JSON file under one lock hold: an array of check IDs or ' +
-        '{ rule, max, reason?, share?, meta?, patch? } objects, or a "lint --per-patch --report" ' +
-        'document, whose ceilings for this patch are rebaselined to their current measurement. ' +
-        'Needs --yes when not run from a terminal')
-        .option('--dry-run', 'Show what would change without writing')
-        .option('-y, --yes', 'Skip confirmation prompt (required for non-TTY)');
-    addWaitLockOption(command).action(withErrorHandling(async (name, options) => {
-        // Commander defaults `--add`/`--remove` to `[]` so they appear in
-        // the options object even when unused. Strip empty arrays so
-        // `pickDefined` sees them as absent. Otherwise the mode-count
-        // mutex would treat zero-length arrays as a present mode.
-        const normalized = {};
-        if (options.add !== undefined && options.add.length > 0)
-            normalized.add = options.add;
-        if (options.remove !== undefined && options.remove.length > 0)
-            normalized.remove = options.remove;
-        if (options.clear === true)
-            normalized.clear = true;
-        if (options.max !== undefined)
-            normalized.max = options.max;
-        if (options.reason !== undefined)
-            normalized.reason = options.reason;
-        if (options.share !== undefined)
-            normalized.share = options.share;
-        if (options.from !== undefined)
-            normalized.from = options.from;
-        if (options.dryRun === true)
-            normalized.dryRun = true;
-        if (options.yes === true)
-            normalized.yes = true;
-        if (options.waitLock !== undefined)
-            normalized.waitLock = options.waitLock;
-        await patchLintIgnoreCommand(getProjectRoot(), name, normalized);
-    }));
-}

package/dist/src/commands/patch/move-files-adopt.d.ts

@@ -1,33 +0,0 @@
-/**
- * `patch move-files --scan-file <path>`: adopt new engine files into the
- * move's destination in the same transaction.
- *
- * Splitting a widget across patches moved existing files and adopted the
- * seam modules that appeared beside them. Adopting first (`re-export
- * --scan --scan-file`) grew the source past its own `large-patch-lines`
- * ceiling, which refused although the move that followed would have
- * shrunk it again. Adopting straight into the destination of the move
- * means no patch ever carries the intermediate body: both sides are linted
- * on what the transaction leaves behind.
- */
-import type { PatchMetadata } from '../../types/commands/index.js';
-/**
- * Validates `--scan-file` paths: each must be engine-relative, exist in
- * `engine/`, be owned by no patch and not be one of the moved files.
- * Returns the sorted, de-duplicated list.
- *
- * @param rawFiles - The `--scan-file` values
- * @param patches - Manifest rows
- * @param enginePath - Engine directory
- * @param movedFiles - The `--file` paths of the same move
- */
-export declare function resolveAdoptedFiles(rawFiles: readonly string[] | undefined, patches: readonly PatchMetadata[], enginePath: string, movedFiles: readonly string[]): Promise<string[]>;
-/**
- * Re-checks under the patch-directory lock that no patch claimed an
- * adopted file while the move waited for confirmation.
- *
- * @param patches - Manifest rows read under the lock
- * @param adoptedFiles - Files the move adopts
- * @param command - Command name for the error
- */
-export declare function assertAdoptedStillUnowned(patches: readonly PatchMetadata[], adoptedFiles: readonly string[] | undefined, command: string): void;

package/dist/src/commands/patch/move-files-adopt.js

@@ -1,65 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * `patch move-files --scan-file <path>`: adopt new engine files into the
- * move's destination in the same transaction.
- *
- * Splitting a widget across patches moved existing files and adopted the
- * seam modules that appeared beside them. Adopting first (`re-export
- * --scan --scan-file`) grew the source past its own `large-patch-lines`
- * ceiling, which refused although the move that followed would have
- * shrunk it again. Adopting straight into the destination of the move
- * means no patch ever carries the intermediate body: both sides are linted
- * on what the transaction leaves behind.
- */
-import { join } from 'node:path';
-import { InvalidArgumentError } from '../../errors/base.js';
-import { pathExists } from '../../utils/fs.js';
-import { normalizeEngineRelativeInput } from '../re-export-scan.js';
-/**
- * Validates `--scan-file` paths: each must be engine-relative, exist in
- * `engine/`, be owned by no patch and not be one of the moved files.
- * Returns the sorted, de-duplicated list.
- *
- * @param rawFiles - The `--scan-file` values
- * @param patches - Manifest rows
- * @param enginePath - Engine directory
- * @param movedFiles - The `--file` paths of the same move
- */
-export async function resolveAdoptedFiles(rawFiles, patches, enginePath, movedFiles) {
-    const files = [
-        ...new Set((rawFiles ?? []).map((raw) => normalizeEngineRelativeInput(raw, '--scan-file'))),
-    ].sort();
-    const moved = new Set(movedFiles);
-    for (const file of files) {
-        if (moved.has(file)) {
-            throw new InvalidArgumentError(`${file} is passed with both --file and --scan-file. --file moves a file the source owns; ` +
-                '--scan-file adopts a file no patch owns yet.', '--scan-file');
-        }
-        const owner = patches.find((patch) => patch.filesAffected.includes(file));
-        if (owner !== undefined) {
-            throw new InvalidArgumentError(`--scan-file path is already owned by ${owner.filename}: ${file}. ` +
-                '--scan-file adopts files no patch owns; move an owned file with --file from its owner.', '--scan-file');
-        }
-        if (!(await pathExists(join(enginePath, file)))) {
-            throw new InvalidArgumentError(`--scan-file path not found in engine/: ${file}. --scan-file adopts a file the worktree ` +
-                'already carries, so it needs content to diff.', '--scan-file');
-        }
-    }
-    return files;
-}
-/**
- * Re-checks under the patch-directory lock that no patch claimed an
- * adopted file while the move waited for confirmation.
- *
- * @param patches - Manifest rows read under the lock
- * @param adoptedFiles - Files the move adopts
- * @param command - Command name for the error
- */
-export function assertAdoptedStillUnowned(patches, adoptedFiles, command) {
-    for (const file of adoptedFiles ?? []) {
-        const owner = patches.find((patch) => patch.filesAffected.includes(file));
-        if (owner !== undefined) {
-            throw new InvalidArgumentError(`Patch queue changed while waiting for confirmation: ${owner.filename} now owns ${file}. Re-run the command.`, command);
-        }
-    }
-}

package/dist/src/commands/patch/move-files-create.d.ts

@@ -1,19 +0,0 @@
-/**
- * `fireforge patch move-files <from> <to> --create --order <n>` creates
- * the target patch at the requested sparse order and moves the files into it
- * as one transaction. This is the transactional bootstrap of a split:
- * without it, moving files into a not-yet-existing patch requires a manual
- * shrink-then-export dance with hand-repointed staged-dependency owners.
- *
- * Mirrors `patch split` end-to-end (same planning, projection lint, policy
- * enforcement, and locked commit). The `<to>` argument becomes the new
- * patch's name/slug the way `split --name` does.
- */
-import type { PatchMoveFilesOptions } from '../../types/commands/index.js';
-/**
- * Runs `patch move-files --create --order <n>`: plans the create+move as a
- * split, lints the projection, confirms, and commits transactionally.
- */
-export declare function patchMoveFilesCreateCommand(projectRoot: string, fromIdentifier: string, newPatchName: string, options: PatchMoveFilesOptions & {
-    order: number;
-}): Promise<void>;