@hominis/fireforge 0.55.0 → 0.60.0

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

@@ -1,91 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * `patch move-files --retire-empty`: fold every file of a patch into
- * another and retire the emptied patch's slot in the same transaction.
- *
- * Without the flag `move-files` refuses to empty the source, and
- * `patch retire` on an emptied patch refuses while another patch's
- * declaration still names it as the owner. With the flag the move re-points
- * those declarations to the destination first (after the fold the
- * destination creates every file the source did), carries the source's own declarations over with its files, and then
- * retires the source the way `patch retire` does: the row and `.patch` file
- * leave, and the order stays spent as a `patches.json#retired` slot so
- * `patchPolicy.allowGaps: false` sees no gap.
- */
-import { rewriteStagedDependencyOwners } from '../../core/patch-manifest.js';
-/**
- * Concatenates declaration lists without duplicates, dropping every entry
- * owned by `destination` itself: after the fold the file it waits for
- * arrives in the same patch, so it is no longer a forward edge.
- */
-function foldDeclarations(lists, destination) {
-    const keys = new Set();
-    const merged = [];
-    for (const entry of lists.flatMap((list) => list ?? [])) {
-        if (entry.owner === destination)
-            continue;
-        const key = JSON.stringify(entry);
-        if (keys.has(key))
-            continue;
-        keys.add(key);
-        merged.push(entry);
-    }
-    return merged;
-}
-/** The destination row carrying its own and the source's declarations. */
-function foldStaged(destination, source) {
-    const own = destination.stagedDependencies;
-    const forwardImports = foldDeclarations([own?.forwardImports, source?.forwardImports], destination.filename);
-    const registrations = foldDeclarations([own?.registrations, source?.registrations], destination.filename);
-    const folded = { ...destination };
-    delete folded.stagedDependencies;
-    if (forwardImports.length === 0 && registrations.length === 0)
-        return folded;
-    folded.stagedDependencies = {
-        ...(forwardImports.length > 0 ? { forwardImports } : {}),
-        ...(registrations.length > 0 ? { registrations } : {}),
-    };
-    return folded;
-}
-/**
- * Re-points every declaration whose owner is `source` to `destination` and
- * carries the source's own declarations onto the destination. The source
- * row is returned unchanged; the caller retires it.
- *
- * @param patches - Manifest rows
- * @param source - Filename of the patch the fold empties
- * @param destination - Filename of the patch that receives its files
- */
-export function foldSourceRows(patches, source, destination) {
-    const lookup = (owner) => owner === source ? destination : undefined;
-    const sourceRow = patches.find((patch) => patch.filename === source);
-    const sourceStaged = sourceRow
-        ? rewriteStagedDependencyOwners(sourceRow, lookup).stagedDependencies
-        : undefined;
-    const repointed = [];
-    const rows = patches.map((patch) => {
-        if (patch.filename === source)
-            return patch;
-        const rewritten = rewriteStagedDependencyOwners(patch, lookup);
-        if (rewritten !== patch)
-            repointed.push(patch.filename);
-        return patch.filename === destination ? foldStaged(rewritten, sourceStaged) : rewritten;
-    });
-    return { patches: rows, repointed };
-}
-/**
- * The retired slot the emptied source leaves, shaped as `patch retire`
- * writes it.
- *
- * @param source - The emptied source row
- * @param destination - Filename of the patch that took its files
- */
-export function retiredSlotForFold(source, destination) {
-    return {
-        order: source.order,
-        category: source.category,
-        filename: source.filename,
-        retiredAt: new Date().toISOString(),
-        reason: `folded into ${destination} by patch move-files --retire-empty`,
-    };
-}

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

@@ -1,28 +0,0 @@
-/**
- * `fireforge patch move-files <from> <to>` previews the explicit
- * re-export choreography needed to move file ownership between two
- * patches. With `--create --order <n>` the target patch is created and
- * the files move into it as one transaction (see move-files-create.ts).
- * `--scan-file` adopts new, unowned engine files into the destination in
- * the same transaction, and `--retire-empty` lets the move empty the
- * source and retire its slot.
- */
-import { Command } from 'commander';
-import type { CommandContext } from '../../types/cli.js';
-import type { PatchMoveFilesOptions } from '../../types/commands/index.js';
-/**
- * Builds and prints a safe, no-write file ownership move plan.
- *
- * @param projectRoot - Project root directory
- * @param fromIdentifier - Patch filename, ordinal, or manifest name that currently owns the files
- * @param toIdentifier - Patch filename, ordinal, or manifest name that should own the files
- * @param options - Files to move and display mode
- */
-export declare function patchMoveFilesCommand(projectRoot: string, fromIdentifier: string, toIdentifier: string, options?: PatchMoveFilesOptions): Promise<void>;
-/**
- * Registers the preview-only `patch move-files` subcommand.
- *
- * @param parent - Parent `patch` command
- * @param context - Shared CLI registration context
- */
-export declare function registerPatchMoveFiles(parent: Command, context: CommandContext): void;

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

@@ -1,224 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * `fireforge patch move-files <from> <to>` previews the explicit
- * re-export choreography needed to move file ownership between two
- * patches. With `--create --order <n>` the target patch is created and
- * the files move into it as one transaction (see move-files-create.ts).
- * `--scan-file` adopts new, unowned engine files into the destination in
- * the same transaction, and `--retire-empty` lets the move empty the
- * source and retire its slot.
- */
-import { relative } from 'node:path';
-import { Command } from 'commander';
-import { getProjectPaths, loadConfig } from '../../core/config.js';
-import { formatPatchNotFoundError } from '../../core/patch-identifier-suggest.js';
-import { loadPatchesManifest, resolvePatchIdentifier } from '../../core/patch-manifest.js';
-import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
-import { pathExists } from '../../utils/fs.js';
-import { info, intro, note, warn } from '../../utils/logger.js';
-import { addWaitLockOption, commanderArgParser, pickDefined, stringListOption, } from '../../utils/options.js';
-import { parsePositiveIntegerFlag } from '../../utils/validation.js';
-import { resolveAdoptedFiles } from './move-files-adopt.js';
-import { patchMoveFilesCreateCommand } from './move-files-create.js';
-import { runMoveFilesInto } from './move-files-into.js';
-function normalizeFileList(files) {
-    const cleaned = (files ?? []).map((file) => file.trim()).filter((file) => file.length > 0);
-    return [...new Set(cleaned)].sort((left, right) => left.localeCompare(right));
-}
-function shellQuote(value) {
-    if (/^[A-Za-z0-9_./:=@%+-]+$/.test(value))
-        return value;
-    return `'${value.replaceAll("'", "'\\''")}'`;
-}
-function formatFiles(files) {
-    return files.length === 0 ? '(none)' : files.map((file) => `  - ${file}`).join('\n');
-}
-function formatReExportCommand(identifier, files, extraFlags) {
-    return [
-        'fireforge',
-        're-export',
-        shellQuote(identifier),
-        '--files',
-        ...files.map(shellQuote),
-        ...extraFlags,
-    ].join(' ');
-}
-function assertPatchHasFiles(owner, files) {
-    const owned = new Set(owner.filesAffected);
-    const missing = files.filter((file) => !owned.has(file));
-    if (missing.length === 0)
-        return;
-    throw new InvalidArgumentError(`${owner.filename} does not currently own ${missing.length} requested file(s):\n${formatFiles(missing)}`, 'patch move-files');
-}
-function assertTargetDoesNotAlreadyOwnFiles(target, files) {
-    const owned = new Set(target.filesAffected);
-    const duplicates = files.filter((file) => owned.has(file));
-    if (duplicates.length === 0)
-        return;
-    throw new InvalidArgumentError(`${target.filename} already owns ${duplicates.length} requested file(s):\n${formatFiles(duplicates)}`, 'patch move-files');
-}
-function computeFileMovePlan(source, target, files, adoptedFiles) {
-    const moved = new Set(files);
-    return {
-        sourceAfter: source.filesAffected.filter((file) => !moved.has(file)).sort(),
-        targetAfter: [...new Set([...target.filesAffected, ...files, ...adoptedFiles])].sort(),
-    };
-}
-/** Refuses a move that empties the source unless `--retire-empty` asks for it, and the flag on a move that does not. */
-function assertEmptySourceIntent(source, sourceAfter, retireEmpty) {
-    if (sourceAfter.length === 0 && !retireEmpty) {
-        throw new InvalidArgumentError(`${source.filename} would have no filesAffected after this move. Pass --retire-empty to ` +
-            'fold it into the destination in one transaction: the declarations it owns re-point to ' +
-            'the destination and its order stays spent as a retired slot.', 'patch move-files');
-    }
-    if (sourceAfter.length > 0 && retireEmpty) {
-        throw new InvalidArgumentError(`--retire-empty applies only to a move that empties the source; ${source.filename} would ` +
-            `keep ${sourceAfter.length} file(s).`, '--retire-empty');
-    }
-}
-/**
- * Builds and prints a safe, no-write file ownership move plan.
- *
- * @param projectRoot - Project root directory
- * @param fromIdentifier - Patch filename, ordinal, or manifest name that currently owns the files
- * @param toIdentifier - Patch filename, ordinal, or manifest name that should own the files
- * @param options - Files to move and display mode
- */
-export async function patchMoveFilesCommand(projectRoot, fromIdentifier, toIdentifier, options = {}) {
-    if (options.create === true && options.order === undefined) {
-        throw new InvalidArgumentError('--create requires --order <n> to place the new patch.', '--create');
-    }
-    if (options.create !== true && options.order !== undefined) {
-        throw new InvalidArgumentError('--order is only valid together with --create.', '--order');
-    }
-    if (options.create === true && options.retireEmpty === true) {
-        throw new InvalidArgumentError('--retire-empty folds the source into an existing patch. To move a whole patch to a new ' +
-            'name or order, use "fireforge patch rename" or "fireforge patch reorder".', '--retire-empty');
-    }
-    if (options.create === true && options.order !== undefined) {
-        await patchMoveFilesCreateCommand(projectRoot, fromIdentifier, toIdentifier, {
-            ...options,
-            order: options.order,
-        });
-        return;
-    }
-    intro('FireForge patch move-files');
-    if (fromIdentifier === toIdentifier) {
-        throw new InvalidArgumentError('Source and target patch identifiers must be different.', 'patch move-files');
-    }
-    const files = normalizeFileList(options.file);
-    if (files.length === 0) {
-        throw new InvalidArgumentError('Specify at least one --file path to move.', 'patch move-files');
-    }
-    const paths = getProjectPaths(projectRoot);
-    if (!(await pathExists(paths.patches))) {
-        throw new GeneralError('Patches directory not found.');
-    }
-    const manifest = await loadPatchesManifest(paths.patches);
-    if (!manifest || manifest.patches.length === 0) {
-        throw new GeneralError('No patches in manifest.');
-    }
-    const source = resolvePatchIdentifier(fromIdentifier, manifest.patches);
-    if (!source) {
-        throw new InvalidArgumentError(formatPatchNotFoundError(fromIdentifier, manifest.patches), fromIdentifier);
-    }
-    const target = resolvePatchIdentifier(toIdentifier, manifest.patches);
-    if (!target) {
-        throw new InvalidArgumentError(formatPatchNotFoundError(toIdentifier, manifest.patches), toIdentifier);
-    }
-    if (source.filename === target.filename) {
-        throw new InvalidArgumentError('Source and target resolved to the same patch.', 'patch move-files');
-    }
-    assertPatchHasFiles(source, files);
-    assertTargetDoesNotAlreadyOwnFiles(target, files);
-    const adoptedFiles = await resolveAdoptedFiles(options.scanFile, manifest.patches, paths.engine, files);
-    const { sourceAfter, targetAfter } = computeFileMovePlan(source, target, files, adoptedFiles);
-    const retireSource = options.retireEmpty === true;
-    assertEmptySourceIntent(source, sourceAfter, retireSource);
-    for (const file of files) {
-        if (!(await pathExists(`${paths.engine}/${file}`))) {
-            warn(`engine/${file} does not exist in the current worktree; re-export may drop or fail it.`);
-        }
-    }
-    const relativePatchesDir = relative(projectRoot, paths.patches) || 'patches';
-    info(`Moving ownership in ${relativePatchesDir}/patches.json.`);
-    info(`Move ${files.length} file(s) from ${source.filename} to ${target.filename}:`);
-    note(formatFiles(files), 'Files');
-    if (adoptedFiles.length > 0)
-        note(formatFiles(adoptedFiles), 'Adopted new files');
-    note(retireSource ? '(none: retired)' : formatFiles(sourceAfter), `${source.filename} files after move`);
-    note(formatFiles(targetAfter), `${target.filename} files after move`);
-    // Manual fallback (e.g. when the worktree cannot carry both patches'
-    // content right now): the equivalent re-export choreography, in
-    // executable order. The shrink must land before the grow, or the
-    // projected cross-patch lint refuses the pair with
-    // duplicate-new-file-creation.
-    const applyTarget = formatReExportCommand(target.filename, targetAfter, ['--yes']);
-    if (!retireSource) {
-        const applySource = formatReExportCommand(source.filename, sourceAfter, [
-            '--allow-shrink',
-            '--yes',
-        ]);
-        note(`1. ${applySource}\n2. ${applyTarget}\n(the shrink must land first)`, 'Equivalent manual commands');
-    }
-    const config = await loadConfig(projectRoot);
-    await runMoveFilesInto({
-        enginePath: paths.engine,
-        patchesDir: paths.patches,
-        source,
-        target,
-        files,
-        sourceAfter,
-        targetAfter,
-        adoptedFiles,
-        retireSource,
-        options,
-        config,
-    });
-}
-/**
- * Registers the preview-only `patch move-files` subcommand.
- *
- * @param parent - Parent `patch` command
- * @param context - Shared CLI registration context
- */
-export function registerPatchMoveFiles(parent, context) {
-    const { getProjectRoot, withErrorHandling } = context;
-    const command = parent
-        .command('move-files <from> <to>')
-        .description('Preview the re-export commands needed to move file ownership between patches, ' +
-        'or create the target patch and move the files in one transaction with --create --order <n>.')
-        .option('--file <path>', 'File path relative to engine/ to move (repeatable)', ...stringListOption())
-        .option('--create', 'Create <to> as a new patch and move the files into it (requires --order)')
-        .option('--order <n>', 'Exact sparse order for the created patch (only valid with --create). With ' +
-        'patchPolicy.allowGaps: false, orders are contiguous within a range: pick a gap, a ' +
-        "retired slot, or the number after the range's last patch; checked before any lint runs", commanderArgParser((raw) => parsePositiveIntegerFlag('--order', raw)))
-        .option('--category <category>', "Category for the created patch (default: the source patch's)")
-        .option('-d, --description <desc>', 'Description for the created patch')
-        .option('--dry-run', 'Show what would happen without writing')
-        .option('-y, --yes', 'Skip confirmation prompt (required for non-TTY)')
-        .option('--scan-file <path>', 'New engine file no patch owns, adopted into <to> in the same transaction (repeatable)', ...stringListOption())
-        .option('--retire-empty', 'Allow the move to empty <from>: re-point the declarations it owns to <to> and retire its slot')
-        .option('--force-unsafe', 'Bypass projected-lint refusals')
-        .option('--skip-lint', 'Skip per-patch lint of the projected bodies')
-        .option('--declarations-out <path>', 'Where a refusal writes its one --from-ready staged-declaration report (default: .fireforge/declarations/<timestamp>.json)');
-    addWaitLockOption(command).action(withErrorHandling(async (from, to, options) => {
-        await patchMoveFilesCommand(getProjectRoot(), from, to, {
-            ...pickDefined({
-                file: options.file,
-                create: options.create,
-                order: options.order,
-                category: options.category,
-                description: options.description,
-                dryRun: options.dryRun,
-                yes: options.yes,
-                forceUnsafe: options.forceUnsafe,
-                skipLint: options.skipLint,
-                declarationsOut: options.declarationsOut,
-                scanFile: options.scanFile,
-                retireEmpty: options.retireEmpty,
-                waitLock: options.waitLock,
-            }),
-        });
-    }));
-}

package/dist/src/commands/patch/move-size-tier.d.ts

@@ -1,27 +0,0 @@
-/**
- * Names a patch-size tier change in a move's lint refusal.
- *
- * `large-patch-lines` judges a patch by its tier: a patch of test files
- * only is held to the test tier, everything else to the general tier
- * (with test lines split out under `addedCode`). A move that takes a
- * source's last product file out turns it into a test-only patch, and the
- * test tier then counts every line against its own ceiling, where a
- * `share: "test"` waiver no longer applies. A plain size error would hide
- * that reordering the moves (tests first) fixes it, so the wrapper below appends which tier the patch moves into, its count and the
- * ceiling that count is held to.
- */
-import { type RunPatchLintOptions } from '../export-shared.js';
-/** One side of a move, linted on its post-transaction body. */
-export interface MoveSideLintOptions extends RunPatchLintOptions {
-    /** The patch's files before the move; absent for a patch the move creates. */
-    filesBefore?: readonly string[];
-    /** How the refusal names the patch (`source`, `destination`). */
-    role: string;
-}
-/**
- * Runs {@link runPatchLint} on one side of a move and, when the lint
- * refuses, appends {@link describeMoveTierChange}'s line to the refusal.
- *
- * @param options - The side's lint options, its files before the move and its role
- */
-export declare function runMoveSideLint(options: MoveSideLintOptions): Promise<void>;

package/dist/src/commands/patch/move-size-tier.js

@@ -1,66 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Names a patch-size tier change in a move's lint refusal.
- *
- * `large-patch-lines` judges a patch by its tier: a patch of test files
- * only is held to the test tier, everything else to the general tier
- * (with test lines split out under `addedCode`). A move that takes a
- * source's last product file out turns it into a test-only patch, and the
- * test tier then counts every line against its own ceiling, where a
- * `share: "test"` waiver no longer applies. A plain size error would hide
- * that reordering the moves (tests first) fixes it, so the wrapper below appends which tier the patch moves into, its count and the
- * ceiling that count is held to.
- */
-import { getPatchSizeThresholds, measurePatchSize, resolvePatchSizeTier, } from '../../core/patch-lint-size.js';
-import { GeneralError } from '../../errors/base.js';
-import { runPatchLint } from '../export-shared.js';
-/**
- * Describes a tier change that leaves the patch above the new tier's
- * `large-patch-lines` error ceiling, or returns undefined when the tier
- * does not change, the rule is waived, or the count fits.
- *
- * @param options - The side's lint options and its files before the move
- */
-async function describeMoveTierChange(options) {
-    const { filesBefore, filesAffected, patchTier, ignoreChecks, config } = options;
-    if (filesBefore === undefined || ignoreChecks?.has('large-patch-lines') === true) {
-        return undefined;
-    }
-    const before = resolvePatchSizeTier(filesBefore, patchTier).tier;
-    const after = resolvePatchSizeTier(filesAffected, patchTier).tier;
-    if (before === after)
-        return undefined;
-    const measurement = await measurePatchSize(options.engineDir, options.diffContent, filesAffected, config);
-    // Under `addedCode` a general-tier patch holds only its non-test lines to
-    // the general ceiling (the test lines meet the test tier's).
-    const count = measurement.metric === 'addedCode' && after === 'general'
-        ? measurement.lines - measurement.testLines
-        : measurement.lines;
-    const limit = getPatchSizeThresholds(after, config).lines.error;
-    if (count <= limit)
-        return undefined;
-    const advice = after === 'test'
-        ? 'Move its test files out before its last product file (or in the same move), ' +
-            'so it never stands as a test-only patch above that ceiling.'
-        : 'Order the moves so it does not change tier while above that ceiling.';
-    return `Tier change: the ${options.role} becomes ${after} tier (it was ${before} tier): ${count} lines against ${limit}. ${advice}`;
-}
-/**
- * Runs {@link runPatchLint} on one side of a move and, when the lint
- * refuses, appends {@link describeMoveTierChange}'s line to the refusal.
- *
- * @param options - The side's lint options, its files before the move and its role
- */
-export async function runMoveSideLint(options) {
-    try {
-        await runPatchLint(options);
-    }
-    catch (error) {
-        if (!(error instanceof GeneralError))
-            throw error;
-        const note = await describeMoveTierChange(options);
-        if (note === undefined)
-            throw error;
-        throw new GeneralError(`${error.message}\n${note}`);
-    }
-}

package/dist/src/commands/patch/patch-context.d.ts

@@ -1,40 +0,0 @@
-/**
- * Shared preamble for the patch subcommands: every mutation command starts
- * by loading the project paths and the patches manifest and (for the
- * single-patch commands) resolving the operator-supplied identifier. This
- * module is the single source for that sequence and its error wording.
- */
-import type { PatchesManifest, PatchMetadata } from '../../types/commands/index.js';
-import type { ProjectPaths } from '../../types/config.js';
-/** Resolved project paths plus the non-empty patches manifest. */
-export interface PatchQueueContext {
-    /** Project paths resolved from the project root. */
-    paths: ProjectPaths;
-    /** The loaded manifest, guaranteed to contain at least one patch. */
-    manifest: PatchesManifest;
-}
-/**
- * Loads the project paths and the patches manifest, throwing the shared
- * command-preamble errors when the patches directory is missing or the
- * manifest has no patches.
- *
- * @param projectRoot - Root directory of the project
- * @param options - Optional overrides for the preamble error wording
- * @param options.missingDirMessage - Replacement for the default
- *   "Patches directory not found." error (e.g. `patch delete` appends
- *   "No patches to delete.")
- * @returns The resolved paths and the non-empty manifest
- */
-export declare function requirePatchQueue(projectRoot: string, options?: {
-    missingDirMessage?: string;
-}): Promise<PatchQueueContext>;
-/**
- * Resolves an operator-supplied patch identifier (order number, filename,
- * or unique name fragment) against the manifest, throwing the shared
- * not-found error with suggestions when no patch matches.
- *
- * @param identifier - Identifier as passed on the command line
- * @param patches - Manifest rows to resolve against
- * @returns The matching manifest row
- */
-export declare function requirePatchTarget(identifier: string, patches: PatchMetadata[]): PatchMetadata;

package/dist/src/commands/patch/patch-context.js

@@ -1,51 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Shared preamble for the patch subcommands: every mutation command starts
- * by loading the project paths and the patches manifest and (for the
- * single-patch commands) resolving the operator-supplied identifier. This
- * module is the single source for that sequence and its error wording.
- */
-import { getProjectPaths } from '../../core/config.js';
-import { formatPatchNotFoundError } from '../../core/patch-identifier-suggest.js';
-import { loadPatchesManifest, resolvePatchIdentifier } from '../../core/patch-manifest.js';
-import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
-import { pathExists } from '../../utils/fs.js';
-/**
- * Loads the project paths and the patches manifest, throwing the shared
- * command-preamble errors when the patches directory is missing or the
- * manifest has no patches.
- *
- * @param projectRoot - Root directory of the project
- * @param options - Optional overrides for the preamble error wording
- * @param options.missingDirMessage - Replacement for the default
- *   "Patches directory not found." error (e.g. `patch delete` appends
- *   "No patches to delete.")
- * @returns The resolved paths and the non-empty manifest
- */
-export async function requirePatchQueue(projectRoot, options = {}) {
-    const paths = getProjectPaths(projectRoot);
-    if (!(await pathExists(paths.patches))) {
-        throw new GeneralError(options.missingDirMessage ?? 'Patches directory not found.');
-    }
-    const manifest = await loadPatchesManifest(paths.patches);
-    if (!manifest || manifest.patches.length === 0) {
-        throw new GeneralError('No patches in manifest.');
-    }
-    return { paths, manifest };
-}
-/**
- * Resolves an operator-supplied patch identifier (order number, filename,
- * or unique name fragment) against the manifest, throwing the shared
- * not-found error with suggestions when no patch matches.
- *
- * @param identifier - Identifier as passed on the command line
- * @param patches - Manifest rows to resolve against
- * @returns The matching manifest row
- */
-export function requirePatchTarget(identifier, patches) {
-    const target = resolvePatchIdentifier(identifier, patches);
-    if (!target) {
-        throw new InvalidArgumentError(formatPatchNotFoundError(identifier, patches), identifier);
-    }
-    return target;
-}

package/dist/src/commands/patch/removal-created-files.d.ts

@@ -1,48 +0,0 @@
-/**
- * What `patch delete` and `patch retire` do to the files the removed patch
- * claims, shared so both commands say and do the same.
- *
- * A file the patch modifies stays in the engine with its edits, unmanaged.
- * A file the patch creates is different: once the patch is gone nothing
- * owns it, so a created file still on disk turns into an unmanaged file the
- * engine-clean gate reports. The summary names each such file (in the dry
- * run and at the prompt), and `--delete-created` removes them as part of
- * the confirmed operation.
- */
-import type { PatchQueueContext } from '../../core/patch-lint.js';
-import type { PatchMetadata } from '../../types/commands/index.js';
-/** The summary lines for a removal's claimed files, and what to delete. */
-export interface ClaimedFilePlan {
-    /** One summary line per claimed file, plus a header. */
-    summary: string[];
-    /** Created files still on disk that the removal will delete. */
-    deleteOnCommit: string[];
-}
-/**
- * Plans the claimed-file half of a removal.
- *
- * @param ctx - Queue context built before the removal
- * @param target - The patch about to leave the queue
- * @param engineDir - Engine directory
- * @param deleteCreated - Whether `--delete-created` was passed
- */
-export declare function planClaimedFiles(ctx: PatchQueueContext, target: PatchMetadata, engineDir: string, deleteCreated: boolean): Promise<ClaimedFilePlan>;
-/**
- * Deletes the created files a confirmed removal planned to delete.
- *
- * @param engineDir - Engine directory
- * @param files - Engine-relative paths from {@link planClaimedFiles}
- */
-export declare function deleteCreatedFiles(engineDir: string, files: readonly string[]): Promise<void>;
-/**
- * Runs a removal's locked commit, inside the engine-session lock as well
- * when it will delete engine files, so no engine-mutating peer runs while
- * created files disappear under it.
- *
- * @param projectRoot - Project root directory
- * @param command - Command name for lock attribution
- * @param plan - The claimed-file plan
- * @param waitLockSeconds - Wait budget for the engine lock
- * @param operation - The patch-directory-locked commit
- */
-export declare function withCreatedFileLock(projectRoot: string, command: string, plan: ClaimedFilePlan, waitLockSeconds: number | undefined, operation: () => Promise<void>): Promise<void>;

package/dist/src/commands/patch/removal-created-files.js

@@ -1,83 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * What `patch delete` and `patch retire` do to the files the removed patch
- * claims, shared so both commands say and do the same.
- *
- * A file the patch modifies stays in the engine with its edits, unmanaged.
- * A file the patch creates is different: once the patch is gone nothing
- * owns it, so a created file still on disk turns into an unmanaged file the
- * engine-clean gate reports. The summary names each such file (in the dry
- * run and at the prompt), and `--delete-created` removes them as part of
- * the confirmed operation.
- */
-import { join } from 'node:path';
-import { withEngineSessionLock } from '../../core/engine-session-lock.js';
-import { pathExists, removeFile } from '../../utils/fs.js';
-/**
- * Plans the claimed-file half of a removal.
- *
- * @param ctx - Queue context built before the removal
- * @param target - The patch about to leave the queue
- * @param engineDir - Engine directory
- * @param deleteCreated - Whether `--delete-created` was passed
- */
-export async function planClaimedFiles(ctx, target, engineDir, deleteCreated) {
-    const created = ctx.entries.find((entry) => entry.filename === target.filename)?.createdFiles;
-    const summary = [`files currently claimed by this patch (${target.filesAffected.length}):`];
-    const deleteOnCommit = [];
-    let lingering = 0;
-    for (const file of target.filesAffected) {
-        if (created?.has(file) !== true) {
-            summary.push(`  ${file}  → will become unmanaged`);
-            continue;
-        }
-        if (!(await pathExists(join(engineDir, file)))) {
-            summary.push(`  ${file}  → created by this patch; already gone`);
-            continue;
-        }
-        if (deleteCreated) {
-            deleteOnCommit.push(file);
-            summary.push(`  ${file}  → created by this patch; will be deleted (--delete-created)`);
-        }
-        else {
-            lingering++;
-            summary.push(`  ${file}  → created by this patch and still on disk: will become unmanaged`);
-        }
-    }
-    if (lingering > 0) {
-        summary.push(`${lingering} created file(s) are still on disk. Delete them first, or pass ` +
-            '--delete-created to remove them with the patch; otherwise status reports them as unmanaged.');
-    }
-    return { summary, deleteOnCommit };
-}
-/**
- * Deletes the created files a confirmed removal planned to delete.
- *
- * @param engineDir - Engine directory
- * @param files - Engine-relative paths from {@link planClaimedFiles}
- */
-export async function deleteCreatedFiles(engineDir, files) {
-    for (const file of files) {
-        await removeFile(join(engineDir, file));
-    }
-}
-/**
- * Runs a removal's locked commit, inside the engine-session lock as well
- * when it will delete engine files, so no engine-mutating peer runs while
- * created files disappear under it.
- *
- * @param projectRoot - Project root directory
- * @param command - Command name for lock attribution
- * @param plan - The claimed-file plan
- * @param waitLockSeconds - Wait budget for the engine lock
- * @param operation - The patch-directory-locked commit
- */
-export async function withCreatedFileLock(projectRoot, command, plan, waitLockSeconds, operation) {
-    if (plan.deleteOnCommit.length === 0) {
-        await operation();
-        return;
-    }
-    await withEngineSessionLock(projectRoot, command, operation, {
-        ...(waitLockSeconds !== undefined ? { waitLockSeconds } : {}),
-    });
-}