@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/commands/patch/removal-dependents.d.ts

@@ -1,63 +0,0 @@
-/**
- * The dependency scan `patch delete` and `patch retire` share: which later
- * patches import a file the removed patch creates, and which staged
- * declarations name it as their owner. Both commands take the patch out of
- * the queue, so both must refuse and warn on exactly the same evidence.
- */
-import type { ConflictReport } from '../../core/destructive.js';
-import { type PatchQueueContext } from '../../core/patch-lint.js';
-import type { PatchMetadata } from '../../types/commands/index.js';
-/**
- * Lists every later patch site that imports a file `target` creates.
- *
- * Both source-site maps are covered: `newFiles` (files the later patch
- * creates) and `modifiedFileAdditions` (added lines against files that
- * already exist). Scanning only newFiles misses a later patch adding
- * `import "./TargetHelper.sys.mjs"` to an existing file. Uses the shared
- * specifier extractor so dynamic `import()` and
- * `ChromeUtils.defineESModuleGetters` are picked up: the forward-import lint
- * rule already covers those forms, and removal safety must match the same
- * set or it silently drops dependencies.
- *
- * @param baseCtx - Queue context built before the removal
- * @param target - The patch about to leave the queue
- * @param command - Names for the "queue changed" refusal, e.g.
- *   `{ noun: 'deletion', verb: 'delete' }`
- * @returns One description per dependent patch
- */
-export declare function collectRemovalDependents(baseCtx: PatchQueueContext, target: PatchMetadata, command: {
-    noun: string;
-    verb: string;
-}): string[];
-/**
- * Warns once per patch whose staged forward-import names `target` as its
- * owner. The dangling reference also surfaces via cross-patch lint later,
- * but warning here puts the exact cleanup command in front of the operator
- * at decision time.
- *
- * @param baseCtx - Queue context built before the removal
- * @param target - The patch about to leave the queue
- * @param verb - Command name used in the warning ("delete", "retire")
- */
-export declare function warnDanglingStagedOwners(baseCtx: PatchQueueContext, target: PatchMetadata, verb: string): void;
-/**
- * The structural conflict a removal with dependents raises.
- *
- * The wording spells out the runtime impact: `git apply` does not resolve
- * imports and succeeds even when a later patch imports a file the target
- * created, so the queue re-imports cleanly. The breakage surfaces at
- * browser startup when `ChromeUtils.importESModule` cannot locate the
- * deleted module. Operators who plan to re-introduce the imported files
- * (rename, refactor) need to know this is the impact model rather than a
- * patch-application failure.
- *
- * @param dependents - Result of {@link collectRemovalDependents}
- * @param target - The patch about to leave the queue
- */
-export declare function removalConflict(dependents: readonly string[], target: PatchMetadata): ConflictReport | null;
-/**
- * Snapshot of the queue inputs a removal's dependency scan read, compared
- * again under the lock so a change between the prompt and the commit
- * refuses instead of committing an unreviewed removal.
- */
-export declare function queueSnapshot(context: PatchQueueContext): string;

package/dist/src/commands/patch/removal-dependents.js

@@ -1,133 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * The dependency scan `patch delete` and `patch retire` share: which later
- * patches import a file the removed patch creates, and which staged
- * declarations name it as their owner. Both commands take the patch out of
- * the queue, so both must refuse and warn on exactly the same evidence.
- */
-import { basename } from 'node:path';
-import { extractImportSpecifiersWithLines, findForwardImportIgnoreLines, isForwardImportableFile, } from '../../core/patch-lint.js';
-import { GeneralError } from '../../errors/base.js';
-import { warn } from '../../utils/logger.js';
-/**
- * Lists every later patch site that imports a file `target` creates.
- *
- * Both source-site maps are covered: `newFiles` (files the later patch
- * creates) and `modifiedFileAdditions` (added lines against files that
- * already exist). Scanning only newFiles misses a later patch adding
- * `import "./TargetHelper.sys.mjs"` to an existing file. Uses the shared
- * specifier extractor so dynamic `import()` and
- * `ChromeUtils.defineESModuleGetters` are picked up: the forward-import lint
- * rule already covers those forms, and removal safety must match the same
- * set or it silently drops dependencies.
- *
- * @param baseCtx - Queue context built before the removal
- * @param target - The patch about to leave the queue
- * @param command - Names for the "queue changed" refusal, e.g.
- *   `{ noun: 'deletion', verb: 'delete' }`
- * @returns One description per dependent patch
- */
-export function collectRemovalDependents(baseCtx, target, command) {
-    const targetEntry = baseCtx.entries.find((e) => e.filename === target.filename);
-    if (!targetEntry || JSON.stringify(targetEntry.metadata) !== JSON.stringify(target)) {
-        throw new GeneralError(`Patch queue changed while preparing ${command.noun}. Re-run patch ${command.verb} to review the current target.`);
-    }
-    const targetNewFileLeaves = new Set();
-    for (const fullPath of targetEntry.newFiles.keys()) {
-        targetNewFileLeaves.add(basename(fullPath));
-    }
-    const dependents = [];
-    const scanSite = (entryFilename, sitePath, content) => {
-        if (!isForwardImportableFile(sitePath))
-            return false;
-        const ignoredLines = findForwardImportIgnoreLines(content);
-        const specifiers = extractImportSpecifiersWithLines(content);
-        for (const { specifier, line } of specifiers) {
-            if (ignoredLines.has(line))
-                continue;
-            const cleaned = specifier.split(/[?#]/)[0] ?? specifier;
-            const leaf = basename(cleaned);
-            if (!leaf || !isForwardImportableFile(leaf))
-                continue;
-            if (targetNewFileLeaves.has(leaf)) {
-                dependents.push(`${entryFilename} (${sitePath}) imports "${specifier}" which would be deleted`);
-                return true;
-            }
-        }
-        return false;
-    };
-    for (const entry of baseCtx.entries) {
-        if (entry.filename === target.filename)
-            continue;
-        if (entry.order < target.order)
-            continue;
-        let matched = false;
-        for (const [newFile, content] of entry.newFiles) {
-            if (scanSite(entry.filename, newFile, content)) {
-                matched = true;
-                break;
-            }
-        }
-        if (matched)
-            continue;
-        for (const [modifiedPath, addedContent] of entry.modifiedFileAdditions) {
-            if (scanSite(entry.filename, modifiedPath, addedContent))
-                break;
-        }
-    }
-    return dependents;
-}
-/**
- * Warns once per patch whose staged forward-import names `target` as its
- * owner. The dangling reference also surfaces via cross-patch lint later,
- * but warning here puts the exact cleanup command in front of the operator
- * at decision time.
- *
- * @param baseCtx - Queue context built before the removal
- * @param target - The patch about to leave the queue
- * @param verb - Command name used in the warning ("delete", "retire")
- */
-export function warnDanglingStagedOwners(baseCtx, target, verb) {
-    const holders = baseCtx.entries.filter((entry) => entry.filename !== target.filename &&
-        (entry.metadata?.stagedDependencies?.forwardImports ?? []).some((fi) => fi.owner === target.filename));
-    for (const holder of holders) {
-        warn(`${holder.filename} declares a staged dependency with owner ${target.filename}; ` +
-            `after the ${verb}, update it via "fireforge patch staged-dependency ${holder.filename} --remove ..." ` +
-            'or re-point the owner at the patch that will create the file.');
-    }
-}
-/**
- * The structural conflict a removal with dependents raises.
- *
- * The wording spells out the runtime impact: `git apply` does not resolve
- * imports and succeeds even when a later patch imports a file the target
- * created, so the queue re-imports cleanly. The breakage surfaces at
- * browser startup when `ChromeUtils.importESModule` cannot locate the
- * deleted module. Operators who plan to re-introduce the imported files
- * (rename, refactor) need to know this is the impact model rather than a
- * patch-application failure.
- *
- * @param dependents - Result of {@link collectRemovalDependents}
- * @param target - The patch about to leave the queue
- */
-export function removalConflict(dependents, target) {
-    if (dependents.length === 0)
-        return null;
-    return {
-        reason: `${dependents.length} later patch(es) contain import statements that reference files created by ${target.filename}. Patch application itself will still succeed, but runtime imports will fail at browser startup until those files are re-introduced.`,
-        details: [...dependents],
-    };
-}
-/**
- * Snapshot of the queue inputs a removal's dependency scan read, compared
- * again under the lock so a change between the prompt and the commit
- * refuses instead of committing an unreviewed removal.
- */
-export function queueSnapshot(context) {
-    return JSON.stringify(context.entries.map(({ filename, order, diff, metadata }) => ({
-        filename,
-        order,
-        diff,
-        metadata,
-    })));
-}

package/dist/src/commands/patch/rename.d.ts

@@ -1,35 +0,0 @@
-/**
- * `fireforge patch rename <name>`: relabels a patch's filename, manifest
- * `name`, and (optionally) `description` without rewriting the `.patch` file
- * body.
- *
- * Companion to `re-export --files <subset>`. Re-export shrinks the body and
- * `filesAffected` but leaves the patch's identity describing the pre-shrink
- * scope. The only alternative for that drift is `delete` + re-export, which
- * briefly removes the patch from the queue, and any forward-import
- * dependent then refuses the re-export until the deleted patch's siblings
- * are rewritten.
- *
- * The filename rename and the manifest mutation happen under the patch
- * directory lock so concurrent exports cannot allocate the new filename, and
- * a filesystem rename failure rolls back before the manifest is touched.
- */
-import { Command } from 'commander';
-import type { CommandContext } from '../../types/cli.js';
-import type { PatchRenameOptions } from '../../types/commands/index.js';
-/**
- * Runs the `patch rename` command: relabels filename + manifest entry
- * (name, category, order, description) for a single patch atomically.
- *
- * @param projectRoot - Project root directory
- * @param identifier - Patch filename, ordinal, or manifest `name`
- * @param options - Command options (at least one change flag required)
- */
-export declare function patchRenameCommand(projectRoot: string, identifier: string, options?: PatchRenameOptions): Promise<void>;
-/**
- * Registers the `patch rename` subcommand on the `patch` parent.
- *
- * @param parent - Parent Commander command
- * @param context - Shared CLI registration context
- */
-export declare function registerPatchRename(parent: Command, context: CommandContext): void;

package/dist/src/commands/patch/rename.js

@@ -1,378 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * `fireforge patch rename <name>`: relabels a patch's filename, manifest
- * `name`, and (optionally) `description` without rewriting the `.patch` file
- * body.
- *
- * Companion to `re-export --files <subset>`. Re-export shrinks the body and
- * `filesAffected` but leaves the patch's identity describing the pre-shrink
- * scope. The only alternative for that drift is `delete` + re-export, which
- * briefly removes the patch from the queue, and any forward-import
- * dependent then refuses the re-export until the deleted patch's siblings
- * are rewritten.
- *
- * The filename rename and the manifest mutation happen under the patch
- * directory lock so concurrent exports cannot allocate the new filename, and
- * a filesystem rename failure rolls back before the manifest is touched.
- */
-import { rename as fsRename } from 'node:fs/promises';
-import { join } from 'node:path';
-import { Command } from 'commander';
-import { loadConfig } from '../../core/config.js';
-import { confirmDestructive } from '../../core/destructive.js';
-import { appendHistoryBestEffort } from '../../core/history-log.js';
-import { patchNameSlug } from '../../core/patch-export.js';
-import { buildPatchQueueContext, formatPatchLintIssue, lintPatchQueue, } from '../../core/patch-lint.js';
-import { withPatchDirectoryLock } from '../../core/patch-lock.js';
-import { loadPatchesManifest, rewriteStagedDependencyOwners, savePatchesManifest, } from '../../core/patch-manifest.js';
-import { buildProjectedManifest, enforcePatchPolicy, getPatchPolicyCategories, isCategoryAllowedByConfig, } from '../../core/patch-policy.js';
-import { carryReservedSlots, carryRetiredSlots } from '../../core/patch-retired.js';
-import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
-import { toError } from '../../utils/errors.js';
-import { pathExists } from '../../utils/fs.js';
-import { info, intro, outro, warn } from '../../utils/logger.js';
-import { addWaitLockOption, commanderArgParser, pickDefined, resolveWaitLockSeconds, } from '../../utils/options.js';
-import { parsePositiveIntegerFlag } from '../../utils/validation.js';
-import { proceedAfterDecision } from '../destructive-decision.js';
-import { requirePatchQueue, requirePatchTarget } from './patch-context.js';
-import { projectReorder } from './reorder-projection.js';
-/**
- * Pulls the ordinal-string + category prefix out of a patch filename so
- * the rename keeps the existing ordinal padding verbatim. Returning the
- * literal substring (rather than recomputing from the parsed integer)
- * avoids any chance of the new filename's ordinal differing from the
- * old by a leading-zero count.
- */
-function splitPatchFilename(filename) {
-    const m = /^(\d+)-([a-z]+)-(.+)\.patch$/.exec(filename);
-    if (!m?.[1] || !m[2] || !m[3])
-        return null;
-    return { ordinalStr: m[1], category: m[2], slug: m[3] };
-}
-/**
- * Performs the rename's transactional core under the patch directory
- * lock: re-reads the manifest, re-checks for filename collisions,
- * renames the `.patch` file on disk (when applicable), writes the
- * updated manifest, and appends a history entry. Filesystem rename
- * happens before the manifest save so an interrupted run never leaves
- * the manifest pointing at a missing file. A manifest-save failure
- * rolls the filesystem rename back.
- */
-async function commitRenameUnderLock(input) {
-    const { patchesDir, target, newFilename, newName, newDescription, filenameChanging, nameChanging, descriptionChanging, orderChanging, categoryChanging, } = input;
-    const identityUpdates = {
-        ...(orderChanging && input.newOrder !== undefined ? { order: input.newOrder } : {}),
-        ...(categoryChanging && input.newCategory !== undefined ? { category: input.newCategory } : {}),
-    };
-    await withPatchDirectoryLock(patchesDir, async () => {
-        const fresh = await loadPatchesManifest(patchesDir);
-        if (!fresh) {
-            throw new GeneralError('Manifest disappeared between resolution and rename.');
-        }
-        const idx = fresh.patches.findIndex((p) => p.filename === target.filename);
-        if (idx === -1) {
-            throw new GeneralError(`Patch ${target.filename} disappeared from the manifest during rename. Re-run after investigating.`);
-        }
-        const before = fresh.patches[idx];
-        if (!before) {
-            throw new GeneralError(`Patch ${target.filename} disappeared from the manifest during rename.`);
-        }
-        if (orderChanging && input.newOrder !== undefined) {
-            const orderHolder = fresh.patches.find((p) => p.order === input.newOrder && p.filename !== target.filename);
-            if (orderHolder) {
-                throw new InvalidArgumentError(`Order ${input.newOrder} was claimed by ${orderHolder.filename} concurrently. Pick an unused order, or use "fireforge patch reorder" to renumber siblings.`, '--order');
-            }
-        }
-        let oldPath;
-        let newPath;
-        if (filenameChanging) {
-            const collisionInLock = fresh.patches.find((p) => p.filename === newFilename && p.filename !== target.filename);
-            if (collisionInLock) {
-                throw new InvalidArgumentError(`Cannot rename to "${newFilename}" — a different patch claimed that filename concurrently.`, 'patch rename');
-            }
-            oldPath = join(patchesDir, target.filename);
-            newPath = join(patchesDir, newFilename);
-            if (await pathExists(newPath)) {
-                throw new InvalidArgumentError(`Cannot rename: ${newFilename} already exists on disk. Resolve manually before retrying.`, 'patch rename');
-            }
-            fresh.patches[idx] = {
-                ...before,
-                filename: newFilename,
-                name: newName,
-                ...identityUpdates,
-                ...(descriptionChanging ? { description: newDescription ?? '' } : {}),
-            };
-            // Staged-dependency owners on other patches reference the old
-            // filename. Remap them so forward-import declarations survive the
-            // rename instead of dangling.
-            const ownerLookup = (old) => old === target.filename ? newFilename : undefined;
-            fresh.patches = fresh.patches.map((p) => rewriteStagedDependencyOwners(p, ownerLookup));
-        }
-        else {
-            fresh.patches[idx] = {
-                ...before,
-                ...identityUpdates,
-                ...(nameChanging ? { name: newName } : {}),
-                ...(descriptionChanging ? { description: newDescription ?? '' } : {}),
-            };
-        }
-        // A rename onto a retired or reserved order fills that slot.
-        const retired = carryRetiredSlots(fresh, fresh.patches);
-        if (retired === undefined)
-            delete fresh.retired;
-        else
-            fresh.retired = retired;
-        const reserved = carryReservedSlots(fresh, fresh.patches);
-        if (reserved === undefined)
-            delete fresh.reserved;
-        else
-            fresh.reserved = reserved;
-        enforcePatchPolicy({
-            config: input.config,
-            manifest: buildProjectedManifest(fresh, fresh.patches),
-            command: 'patch rename',
-            forceUnsafe: input.forceUnsafe === true,
-        });
-        if (filenameChanging && oldPath !== undefined && newPath !== undefined) {
-            await fsRename(oldPath, newPath);
-            try {
-                await savePatchesManifest(patchesDir, fresh);
-            }
-            catch (saveError) {
-                try {
-                    await fsRename(newPath, oldPath);
-                }
-                catch (rollbackError) {
-                    warn(`Rollback warning: could not restore ${target.filename} after manifest write failure: ${toError(rollbackError).message}`);
-                }
-                throw saveError;
-            }
-        }
-        else {
-            await savePatchesManifest(patchesDir, fresh);
-        }
-        await appendHistoryBestEffort(patchesDir, {
-            operation: 'patch-rename',
-            args: {
-                oldFilename: target.filename,
-                newFilename,
-                oldName: target.name,
-                newName,
-                ...(descriptionChanging ? { oldDescription: target.description, newDescription } : {}),
-                ...(orderChanging ? { oldOrder: target.order, newOrder: input.newOrder } : {}),
-                ...(categoryChanging
-                    ? { oldCategory: target.category, newCategory: input.newCategory }
-                    : {}),
-            },
-            ...(input.yes === true ? { yes: true } : {}),
-            ...(input.forceUnsafe === true ? { unsafeOverride: true } : {}),
-            result: 'ok',
-        }, `patch rename committed (${newFilename})`);
-    }, { waitLockSeconds: input.waitLockSeconds, command: 'patch rename' });
-}
-/** Validates the flags and resolves the new filename/identity fields. */
-function resolveRenamePlan(target, options, config) {
-    const hasTo = options.to !== undefined && options.to.trim() !== '';
-    if (!hasTo &&
-        options.category === undefined &&
-        options.order === undefined &&
-        options.description === undefined) {
-        throw new InvalidArgumentError('Specify at least one of --to <new-name>, --category <category>, --order <n>, or --description. --to is sanitised into the filename slug the same way `export --name` is.', 'patch rename');
-    }
-    const split = splitPatchFilename(target.filename);
-    if (!split) {
-        throw new GeneralError(`Cannot rename ${target.filename}: filename does not match the expected {ordinal}-{category}-{slug}.patch convention. Re-export the patch instead.`);
-    }
-    const newCategory = options.category ?? split.category;
-    if (options.category !== undefined && !isCategoryAllowedByConfig(config, options.category)) {
-        throw new InvalidArgumentError(`Invalid category. Must be one of: ${getPatchPolicyCategories(config).join(', ')}`, '--category');
-    }
-    // Keep the existing slug verbatim when --to is absent: re-running
-    // `patchNameSlug` against a different category could strip a
-    // category-looking prefix out of an established slug.
-    const newSlug = hasTo && options.to !== undefined ? patchNameSlug(options.to, newCategory) : split.slug;
-    if (newSlug === '') {
-        throw new InvalidArgumentError('--to must contain at least one alphanumeric character after sanitisation.', 'patch rename');
-    }
-    // Preserve the ordinal's zero-padding width. A wider order simply
-    // prints unpadded-longer.
-    const newOrdinalStr = options.order !== undefined
-        ? String(options.order).padStart(split.ordinalStr.length, '0')
-        : split.ordinalStr;
-    const newFilename = `${newOrdinalStr}-${newCategory}-${newSlug}.patch`;
-    return {
-        hasTo,
-        newCategory,
-        newSlug,
-        newFilename,
-        filenameChanging: newFilename !== target.filename,
-        nameChanging: hasTo && options.to !== target.name,
-        descriptionChanging: options.description !== undefined && options.description !== target.description,
-        orderChanging: options.order !== undefined && options.order !== target.order,
-        categoryChanging: options.category !== undefined &&
-            (options.category !== target.category || options.category !== split.category),
-    };
-}
-/**
- * Pre-flight refusals: order collision (with a pointer to the verb that
- * renumbers siblings, and `--order` means "this exact unused sparse slot",
- * mirroring `export --order`), projected cross-patch lint on an order
- * change (forward imports resolve by queue position), and the
- * filename collision. The authoritative collision checks run again inside
- * the lock to close the TOCTOU window.
- */
-async function assertRenamePreconditions(patchesDir, manifest, target, plan, options, config) {
-    if (plan.orderChanging && options.order !== undefined) {
-        const holder = manifest.patches.find((p) => p.order === options.order && p.filename !== target.filename);
-        if (holder) {
-            throw new InvalidArgumentError(`Order ${options.order} is already used by ${holder.filename}. Pick an unused order, or use "fireforge patch reorder ${target.filename} --to ${options.order}" to renumber siblings.`, '--order');
-        }
-        if (options.forceUnsafe !== true) {
-            const baseCtx = await buildPatchQueueContext(patchesDir, config);
-            const projected = projectReorder(baseCtx, new Map([[target.filename, { newFilename: plan.newFilename, newOrder: options.order }]]));
-            const projectedErrors = lintPatchQueue(projected).filter((i) => i.severity === 'error');
-            if (projectedErrors.length > 0) {
-                throw new InvalidArgumentError(`Refusing to run patch rename: the order change would introduce ${projectedErrors.length} cross-patch lint error(s):\n  ${projectedErrors
-                    .map(formatPatchLintIssue)
-                    .join('\n  ')}\nPass --force-unsafe to override.`, '--force-unsafe');
-            }
-        }
-    }
-    if (plan.filenameChanging) {
-        const collision = manifest.patches.find((p) => p.filename === plan.newFilename && p.filename !== target.filename);
-        if (collision) {
-            throw new InvalidArgumentError(`Cannot rename to "${plan.newFilename}" — a different patch already uses that filename.`, 'patch rename');
-        }
-    }
-}
-/** Change-summary lines shown by the confirmation prompt. */
-function buildRenameSummary(target, plan, options) {
-    const summary = [];
-    if (plan.filenameChanging) {
-        summary.push(`rename ${target.filename} → ${plan.newFilename}`);
-    }
-    if (plan.nameChanging) {
-        summary.push(`name: "${target.name}" → "${options.to}"`);
-    }
-    if (plan.descriptionChanging) {
-        summary.push(`description: "${target.description || '(none)'}" → "${options.description ?? '(none)'}"`);
-    }
-    if (plan.orderChanging && options.order !== undefined) {
-        summary.push(`order: ${target.order} → ${options.order}`);
-    }
-    if (plan.categoryChanging) {
-        summary.push(`category: ${target.category} → ${plan.newCategory}`);
-    }
-    return summary;
-}
-/**
- * Runs the `patch rename` command: relabels filename + manifest entry
- * (name, category, order, description) for a single patch atomically.
- *
- * @param projectRoot - Project root directory
- * @param identifier - Patch filename, ordinal, or manifest `name`
- * @param options - Command options (at least one change flag required)
- */
-export async function patchRenameCommand(projectRoot, identifier, options = {}) {
-    const isDryRun = options.dryRun === true;
-    intro(isDryRun ? 'FireForge patch rename (dry run)' : 'FireForge patch rename');
-    const config = await loadConfig(projectRoot);
-    const { paths, manifest } = await requirePatchQueue(projectRoot);
-    const target = requirePatchTarget(identifier, manifest.patches);
-    const plan = resolveRenamePlan(target, options, config);
-    const { hasTo, newCategory, newSlug, newFilename, filenameChanging, nameChanging, descriptionChanging, orderChanging, categoryChanging, } = plan;
-    if (!filenameChanging &&
-        !nameChanging &&
-        !descriptionChanging &&
-        !orderChanging &&
-        !categoryChanging) {
-        info(`${target.filename}: nothing to change — filename already "${target.filename}"` +
-            (hasTo && options.to !== undefined ? ` (slug of "${options.to}" is "${newSlug}")` : '') +
-            `, name already "${target.name}"` +
-            (options.description !== undefined ? ', description already matches' : '') +
-            '.');
-        outro(isDryRun ? 'Dry run complete — no changes made' : 'Patch rename (no-op)');
-        return;
-    }
-    await assertRenamePreconditions(paths.patches, manifest, target, plan, options, config);
-    const summary = buildRenameSummary(target, plan, options);
-    enforcePatchPolicy({
-        config,
-        manifest: buildProjectedManifest(manifest, manifest.patches.map((entry) => entry.filename === target.filename
-            ? {
-                ...entry,
-                filename: newFilename,
-                name: nameChanging ? (options.to ?? entry.name) : entry.name,
-                ...(orderChanging && options.order !== undefined ? { order: options.order } : {}),
-                ...(categoryChanging ? { category: newCategory } : {}),
-                ...(descriptionChanging ? { description: options.description ?? '' } : {}),
-            }
-            : entry)),
-        command: 'patch rename',
-        forceUnsafe: options.forceUnsafe === true,
-    });
-    // A description-only edit renames nothing and moves no order, so it needs
-    // no confirmation: scripts may change a description without --yes.
-    const descriptionOnly = descriptionChanging &&
-        !filenameChanging &&
-        !nameChanging &&
-        !orderChanging &&
-        !categoryChanging;
-    const decision = await confirmDestructive({
-        operation: 'patch-rename',
-        title: `Rename ${target.filename}`,
-        summary,
-        yes: options.yes === true || descriptionOnly,
-        dryRun: isDryRun,
-        conflicts: null,
-    });
-    if (!proceedAfterDecision(decision, 'Rename cancelled'))
-        return;
-    await commitRenameUnderLock({
-        patchesDir: paths.patches,
-        target,
-        newFilename,
-        newName: hasTo && options.to !== undefined ? options.to : target.name,
-        ...(options.description !== undefined ? { newDescription: options.description } : {}),
-        ...(orderChanging && options.order !== undefined ? { newOrder: options.order } : {}),
-        ...(categoryChanging ? { newCategory } : {}),
-        filenameChanging,
-        nameChanging,
-        descriptionChanging,
-        orderChanging,
-        categoryChanging,
-        ...(options.yes === true ? { yes: true } : {}),
-        ...(options.forceUnsafe === true ? { forceUnsafe: true } : {}),
-        config,
-        waitLockSeconds: resolveWaitLockSeconds(options.waitLock),
-    });
-    if (filenameChanging) {
-        info(`${target.filename} → ${newFilename}`);
-    }
-    else {
-        info(`${target.filename}: metadata updated.`);
-    }
-    outro('Patch rename complete');
-}
-/**
- * Registers the `patch rename` subcommand on the `patch` parent.
- *
- * @param parent - Parent Commander command
- * @param context - Shared CLI registration context
- */
-export function registerPatchRename(parent, context) {
-    const { getProjectRoot, withErrorHandling } = context;
-    const command = parent
-        .command('rename <name>')
-        .description('Rename a patch: filename, manifest name, category, order, and/or description update in one transaction without rewriting the .patch body.')
-        .option('--to <new-name>', 'New human-readable name, category-prefixed slug, or full filename stem (normalised into the filename slug)')
-        .option('--category <category>', 'New category for the patch (validated against configured categories); rewrites the filename prefix and manifest row in one transaction')
-        .option('--order <n>', 'Move the patch to this exact unused order; refuses on collision — use "patch reorder" to renumber siblings', commanderArgParser((raw) => parsePositiveIntegerFlag('--order', raw)))
-        .option('-d, --description <text>', 'Replacement description (omit to leave description unchanged)')
-        .option('--dry-run', 'Show what would change without writing')
-        .option('-y, --yes', 'Skip confirmation prompt (required for non-TTY)')
-        .option('--force-unsafe', 'Bypass force-mode patchPolicy refusals');
-    addWaitLockOption(command).action(withErrorHandling(async (name, options) => {
-        await patchRenameCommand(getProjectRoot(), name, pickDefined(options));
-    }));
-}

package/dist/src/commands/patch/reorder-projection.d.ts

@@ -1,17 +0,0 @@
-/**
- * Rename-map helpers shared by `patch reorder` (single-patch moves and
- * `--shift`), `patch compact` and `patch rename --order`: the filename a
- * patch takes at a new order, and the queue context projected through a
- * rename map for cross-patch lint.
- */
-import type { PatchQueueContext } from '../../core/patch-lint.js';
-import { type PatchRenameEntry } from '../../core/patch-manifest.js';
-import type { PatchMetadata } from '../../types/commands/index.js';
-/** Builds a new patch filename by replacing the numeric prefix with `newOrder`. */
-export declare function rebuildFilenameForOrder(existing: PatchMetadata, newOrder: number): string;
-/**
- * Applies a rename map to a {@link PatchQueueContext} so cross-patch lint
- * can run against the projected state without touching disk. Exported for
- * `patch rename --order`, which projects the same single-row move shape.
- */
-export declare function projectReorder(base: PatchQueueContext, renameMap: Map<string, PatchRenameEntry>): PatchQueueContext;