@hominis/fireforge 0.55.0 → 0.60.0

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

@@ -1,367 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * `fireforge patch split <source> --files <p...> --name <n>` moves files
- * out of an existing patch into a brand-new patch as one transaction.
- *
- * Splitting a patch whose files have inbound forward-imports otherwise
- * requires a precise manual order: re-point each staged-dependency owner at
- * a not-yet-created patch, shrink the source via
- * `re-export --files --allow-shrink`, then `export --order`. Any other
- * order refuses or needs `--force-unsafe`. Split performs the shrink, the
- * new-patch creation, and the dependent owner rewrites under one
- * patch-directory lock with rollback, validating only the final projection.
- *
- * Preconditions match `re-export`: the engine worktree must currently
- * reflect both patches' content, because both bodies are regenerated from
- * the worktree.
- */
-import { join } from 'node:path';
-import { Command } from 'commander';
-import { getProjectPaths, loadConfig } from '../../core/config.js';
-import { assertConfirmationAvailable, confirmDestructive } from '../../core/destructive.js';
-import { appendHistoryBestEffort } from '../../core/history-log.js';
-import { formatPatchNotFoundError } from '../../core/patch-identifier-suggest.js';
-import { buildPatchQueueContext } from '../../core/patch-lint.js';
-import { buildLintIgnoreChecks } from '../../core/patch-lint-ignore.js';
-import { withPatchDirectoryLock } from '../../core/patch-lock.js';
-import { loadPatchesManifest, renumberPatchesInManifest, resolvePatchIdentifier, savePatchesManifest, validatePatchesManifest, } from '../../core/patch-manifest.js';
-import { enforcePatchPolicy } from '../../core/patch-policy.js';
-import { manifestWithRetiredSlots } from '../../core/patch-retired.js';
-import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
-import { toError } from '../../utils/errors.js';
-import { readText, removeFile, writeText } from '../../utils/fs.js';
-import { info, intro, outro, success, warn } from '../../utils/logger.js';
-import { addWaitLockOption, commanderArgParser, pickDefined, resolveWaitLockSeconds, } from '../../utils/options.js';
-import { normalizePatchDisplayName, parsePositiveIntegerFlag } from '../../utils/validation.js';
-import { withDeclarationsReport } from '../declarations-report.js';
-import { proceedAfterDecision } from '../destructive-decision.js';
-import { placementPlansEqual, resolvePlacementPlan } from '../export-flow.js';
-import { writeRenameMapFile } from '../patch-rename-map.js';
-import { assertAdoptedStillUnowned } from './move-files-adopt.js';
-import { runMoveSideLint } from './move-size-tier.js';
-import { assertSourceOwnsFiles, buildNewPatchMetadata, buildSplitDiff, buildSplitSummary, mergeStagedForwardImports, projectSplitManifest, runProjectedSplitLint, splitDeclarationReason, splitDeclarationRenamer, } from './split-plan.js';
-import { describeStagedMaintenance, emptyStagedMaintenance, findOwnerRewriteHolders, rewriteSplitOwners, withoutDroppedDeclarations, withoutRelocatedDeclarations, } from './split-staged.js';
-/**
- * History payload for the declarations a split re-homed or dropped, omitted
- * when it touched none so unaffected records keep their old shape.
- */
-function stagedMaintenanceHistory(plan) {
-    const { relocated, dropped } = plan.stagedMaintenance;
-    const relocatedCount = (relocated.forwardImports?.length ?? 0) + (relocated.registrations?.length ?? 0);
-    return {
-        ...(relocatedCount > 0 ? { relocatedDeclarations: relocated } : {}),
-        ...(dropped.length > 0 ? { droppedDeclarations: dropped } : {}),
-    };
-}
-/**
- * Prints the owner rewrites and the declarations the move re-homed or
- * dropped, after a committed split or `move-files --create`.
- */
-export function reportSplitStagedChanges(plan) {
-    if (plan.ownerRewrites.length > 0) {
-        info(`Re-pointed staged-dependency owners in: ${plan.ownerRewrites.join(', ')}`);
-    }
-    for (const line of describeStagedMaintenance(plan.stagedMaintenance, plan.source.filename, plan.placement.newFilename)) {
-        info(line);
-    }
-}
-/**
- * Commits a confirmed split under the patch directory lock: renumber →
- * write new patch body → write shrunken source body → single manifest
- * rewrite (new row + shrunken source row + owner rewrites). On any
- * failure the steps are rolled back in reverse order. Exported for
- * `patch move-files --create`, which commits the same transaction shape.
- */
-export async function commitPatchSplit(patchesDir, plan, newMetadata, options, config) {
-    await withPatchDirectoryLock(patchesDir, async () => {
-        const manifest = await loadPatchesManifest(patchesDir);
-        if (!manifest)
-            throw new GeneralError('Manifest disappeared while waiting for lock.');
-        const current = manifest.patches.find((p) => p.filename === plan.source.filename);
-        if (!current || current.filesAffected.join('\n') !== plan.source.filesAffected.join('\n')) {
-            throw new InvalidArgumentError('Patch queue changed while waiting for split confirmation. Re-run the command.', 'patch split');
-        }
-        assertAdoptedStillUnowned(manifest.patches, plan.adoptedFiles, 'patch split');
-        const currentPlacement = await resolvePlacementPlan(patchesDir, plan.placementOptions, plan.category, plan.name, config);
-        if (!placementPlansEqual(currentPlacement, plan.placement)) {
-            throw new InvalidArgumentError('Patch queue changed while waiting for split confirmation. Re-run the command.', 'patch split');
-        }
-        const movedSet = new Set(plan.movedFiles);
-        const effectiveSourceFilename = plan.placement.renameMap.get(plan.source.filename)?.newFilename ?? plan.source.filename;
-        const newPatchPath = join(patchesDir, plan.placement.newFilename);
-        const sourcePathBefore = join(patchesDir, plan.source.filename);
-        const sourcePathAfter = join(patchesDir, effectiveSourceFilename);
-        const originalSourceBody = await readText(sourcePathBefore);
-        let renumberApplied = false;
-        let newPatchWritten = false;
-        let sourceRewritten = false;
-        try {
-            if (plan.placement.renameMap.size > 0) {
-                await renumberPatchesInManifest(patchesDir, plan.placement.renameMap);
-                renumberApplied = true;
-            }
-            await writeText(newPatchPath, plan.movedDiff);
-            newPatchWritten = true;
-            await writeText(sourcePathAfter, plan.remainingDiff);
-            sourceRewritten = true;
-            const fresh = await loadPatchesManifest(patchesDir);
-            if (!fresh)
-                throw new GeneralError('Manifest disappeared during split commit.');
-            const updatedPatches = fresh.patches.map((patch) => {
-                let withOwners = rewriteSplitOwners(patch, effectiveSourceFilename, movedSet, plan.placement.newFilename);
-                // Persist the auto-declared forward edges into the new patch so the
-                // real per-patch gate stays clean (keyed by post-rename filename).
-                const decls = plan.stagedDependencyAdditions.get(withOwners.filename);
-                if (decls?.length) {
-                    withOwners = mergeStagedForwardImports(withOwners, decls);
-                }
-                withOwners = withoutDroppedDeclarations(withOwners, plan.stagedMaintenance.dropped);
-                if (patch.filename !== effectiveSourceFilename)
-                    return withOwners;
-                return {
-                    ...withoutRelocatedDeclarations(withOwners, movedSet),
-                    filesAffected: plan.remainingFiles,
-                };
-            });
-            updatedPatches.push(newMetadata);
-            updatedPatches.sort((a, b) => a.order - b.order || a.filename.localeCompare(b.filename));
-            const updated = validatePatchesManifest(manifestWithRetiredSlots(fresh, updatedPatches));
-            await savePatchesManifest(patchesDir, updated);
-            await appendHistoryBestEffort(patchesDir, {
-                operation: 'patch-split',
-                args: {
-                    source: effectiveSourceFilename,
-                    newFilename: plan.placement.newFilename,
-                    order: plan.placement.insertionOrder,
-                    files: plan.movedFiles,
-                    ownerRewrites: plan.ownerRewrites,
-                    ...stagedMaintenanceHistory(plan),
-                    renames: [...plan.placement.renameMap.entries()].map(([from, entry]) => ({
-                        from,
-                        to: entry.newFilename,
-                    })),
-                },
-                ...(options.yes === true ? { yes: true } : {}),
-                ...(options.forceUnsafe === true ? { unsafeOverride: true } : {}),
-                result: 'ok',
-            }, `patch split committed`);
-        }
-        catch (error) {
-            // Reverse-order rollback. Each step warns on its own failure so the
-            // original error stays visible.
-            if (sourceRewritten) {
-                try {
-                    await writeText(sourcePathAfter, originalSourceBody);
-                }
-                catch (rollbackError) {
-                    warn(`Rollback warning: could not restore source body: ${toError(rollbackError).message}`);
-                }
-            }
-            if (newPatchWritten) {
-                try {
-                    await removeFile(newPatchPath);
-                }
-                catch (rollbackError) {
-                    warn(`Rollback warning: could not remove new patch file: ${toError(rollbackError).message}`);
-                }
-            }
-            if (renumberApplied) {
-                const inverseMap = new Map([...plan.placement.renameMap.entries()].map(([oldFilename, entry]) => [
-                    entry.newFilename,
-                    {
-                        newOrder: parseInt(oldFilename.split('-')[0] ?? '0', 10),
-                        newFilename: oldFilename,
-                    },
-                ]));
-                try {
-                    await renumberPatchesInManifest(patchesDir, inverseMap);
-                }
-                catch (rollbackError) {
-                    warn(`Rollback warning: could not invert renumber: ${toError(rollbackError).message}`);
-                }
-            }
-            try {
-                await savePatchesManifest(patchesDir, manifest);
-            }
-            catch (rollbackError) {
-                warn(`Rollback warning: could not restore manifest: ${toError(rollbackError).message}`);
-            }
-            throw error;
-        }
-    }, { waitLockSeconds: resolveWaitLockSeconds(options.waitLock), command: 'patch split' });
-}
-/**
- * Runs the `patch split` command: plans the split, lints the projection,
- * confirms, and commits transactionally.
- */
-export async function patchSplitCommand(projectRoot, sourceId, options) {
-    intro(options.dryRun ? 'FireForge patch split (dry run)' : 'FireForge patch split');
-    // Refuse a prompt-less run before doing the diff/lint work.
-    assertConfirmationAvailable('patch split', options);
-    const paths = getProjectPaths(projectRoot);
-    const config = await loadConfig(projectRoot);
-    const manifest = await loadPatchesManifest(paths.patches);
-    if (!manifest || manifest.patches.length === 0) {
-        throw new GeneralError('No patches in manifest.');
-    }
-    const source = resolvePatchIdentifier(sourceId, manifest.patches);
-    if (!source) {
-        throw new InvalidArgumentError(formatPatchNotFoundError(sourceId, manifest.patches), 'patch split');
-    }
-    const movedFiles = [...new Set(options.files.map((f) => f.trim()).filter(Boolean))].sort();
-    if (movedFiles.length === 0) {
-        throw new InvalidArgumentError('patch split requires at least one --files path.', '--files');
-    }
-    assertSourceOwnsFiles(source, movedFiles);
-    const movedSet = new Set(movedFiles);
-    const remainingFiles = source.filesAffected.filter((f) => !movedSet.has(f));
-    if (remainingFiles.length === 0) {
-        throw new InvalidArgumentError(`Splitting every file out of ${source.filename} would leave it empty. ` +
-            'Use "fireforge patch rename" / "fireforge patch reorder" to repurpose or move the whole patch instead.', '--files');
-    }
-    const movedDiff = await buildSplitDiff(paths.engine, movedFiles, 'moved', source.filename);
-    const remainingDiff = await buildSplitDiff(paths.engine, remainingFiles, 'remaining', source.filename);
-    const category = options.category ?? source.category;
-    const placementOptions = pickDefined({
-        order: options.order,
-        before: options.before,
-        after: options.after ??
-            (options.order === undefined && options.before === undefined ? source.filename : undefined),
-    });
-    const placement = await resolvePlacementPlan(paths.patches, placementOptions, category, options.name, config);
-    // The filename slug pipeline strips redundant category prefixes. The
-    // manifest display name must agree with the bare-slug naming policy,
-    // exactly as `export --name` already does.
-    const displayName = normalizePatchDisplayName(options.name, category);
-    if (displayName !== options.name) {
-        info(`Patch name normalized: "${options.name}" → "${displayName}" (the filename carries the order and category prefix).`);
-    }
-    const plan = {
-        source,
-        movedFiles,
-        remainingFiles,
-        movedDiff,
-        remainingDiff,
-        placement,
-        placementOptions,
-        category,
-        name: displayName,
-        description: options.description ?? '',
-        ownerRewrites: findOwnerRewriteHolders(manifest.patches, source.filename, movedSet),
-        // Populated by runProjectedSplitLint below (forward edges into the new
-        // patch, and the declarations the move re-homes or makes unused).
-        stagedDependencyAdditions: new Map(),
-        stagedMaintenance: emptyStagedMaintenance(),
-    };
-    // Policy first: the projected manifest (orders, ranges, the gap rule)
-    // does not depend on the lint below, so a refused --order fails before
-    // the per-patch and projected lint passes instead of after them.
-    enforcePatchPolicy({
-        config,
-        manifest: projectSplitManifest(manifest, plan, buildNewPatchMetadata(plan, config)),
-        command: 'patch split',
-        forceUnsafe: options.forceUnsafe === true,
-    });
-    // Per-patch lint both projected bodies, threading the source patch's
-    // tier/lintIgnore so an intentional-advisory patch can still split.
-    // The whole-queue context (built once, with the config for committed-gate
-    // parity) resolves cross-patch imports and sibling head.js harness roots
-    // instead of linting each projected body blind.
-    const patchQueueCtx = await buildPatchQueueContext(paths.patches, config);
-    const ignoreChecks = buildLintIgnoreChecks(source.lintIgnore);
-    await runMoveSideLint({
-        engineDir: paths.engine,
-        filesAffected: remainingFiles,
-        filesBefore: source.filesAffected,
-        role: 'source',
-        diffContent: remainingDiff,
-        config,
-        skipLint: options.skipLint,
-        patchQueueCtx,
-        ignoreChecks,
-        patchTier: source.tier,
-    });
-    await runMoveSideLint({
-        engineDir: paths.engine,
-        filesAffected: movedFiles,
-        role: 'new patch',
-        diffContent: movedDiff,
-        config,
-        skipLint: options.skipLint,
-        patchQueueCtx,
-        ignoreChecks,
-        patchTier: source.tier,
-    });
-    const projected = runProjectedSplitLint(plan, patchQueueCtx);
-    plan.stagedDependencyAdditions = projected.stagedDependencyAdditions;
-    plan.stagedMaintenance = projected.stagedMaintenance;
-    const conflicts = await withDeclarationsReport(projected.conflicts, {
-        projectRoot,
-        regressions: projected.regressions,
-        out: options.declarationsOut,
-        rename: splitDeclarationRenamer(plan),
-        reason: splitDeclarationReason(plan),
-    });
-    const newMetadata = buildNewPatchMetadata(plan, config);
-    const decision = await confirmDestructive({
-        operation: 'patch-split',
-        title: `Split ${plan.movedFiles.length} file(s) out of ${source.filename} into ${placement.newFilename}`,
-        summary: buildSplitSummary(plan),
-        yes: options.yes === true,
-        dryRun: options.dryRun === true,
-        unsafeOverride: options.forceUnsafe === true,
-        conflicts,
-    });
-    if (!proceedAfterDecision(decision, 'Split cancelled'))
-        return;
-    await commitPatchSplit(paths.patches, plan, newMetadata, options, config);
-    if (options.mapOut !== undefined) {
-        const written = await writeRenameMapFile(options.mapOut, plan.placement.renameMap);
-        info(`Wrote the old-to-new filename map (${plan.placement.renameMap.size} rename(s)) to ${written}`);
-    }
-    success(`Split ${source.filename}: ${placement.newFilename} now owns ${plan.movedFiles.length} file(s)`);
-    reportSplitStagedChanges(plan);
-    outro('Split complete');
-}
-/**
- * Registers the `patch split` subcommand on the `patch` parent.
- */
-export function registerPatchSplit(parent, context) {
-    const { getProjectRoot, withErrorHandling } = context;
-    const command = parent
-        .command('split <source>')
-        .description('Move files out of a patch into a new patch as one transaction (shrink + create + staged-dependency owner rewrites)')
-        .requiredOption('--files <path...>', 'Engine-relative files to move from the source patch to the new patch')
-        .requiredOption('--name <name>', 'Name for the new patch')
-        .option('--category <category>', "Category for the new patch (default: the source patch's)")
-        .option('--description <desc>', 'Description for the new patch')
-        .option('--order <n>', 'Exact sparse order for the new patch', commanderArgParser((raw) => parsePositiveIntegerFlag('--order', raw)))
-        .option('--before <patch>', 'Place the new patch before this patch')
-        .option('--after <patch>', 'Place the new patch after this patch (default: the source patch)')
-        .option('--dry-run', 'Show what would happen without writing')
-        .option('-y, --yes', 'Skip confirmation prompt (required for non-TTY)')
-        .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)')
-        .option('--map-out <file>', 'Write the old-to-new filename map of the patches the split renumbers as JSON');
-    addWaitLockOption(command).action(withErrorHandling(async (sourceId, options) => {
-        await patchSplitCommand(getProjectRoot(), sourceId, {
-            files: options.files,
-            name: options.name,
-            ...pickDefined({
-                category: options.category,
-                description: options.description,
-                order: options.order,
-                before: options.before,
-                after: options.after,
-                dryRun: options.dryRun,
-                yes: options.yes,
-                forceUnsafe: options.forceUnsafe,
-                skipLint: options.skipLint,
-                declarationsOut: options.declarationsOut,
-                mapOut: options.mapOut,
-                waitLock: options.waitLock,
-            }),
-        });
-    }));
-}

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

@@ -1,34 +0,0 @@
-/**
- * `fireforge patch stage <name>...`: stages the named patches' `.patch`
- * files and only their rows of `patches/patches.json` in the project
- * repository's git index.
- *
- * The case it exists for: several sessions edit one checkout's queue, and
- * each must commit only its own patches. Staging the whole manifest takes
- * every session's rows; staging one owner's hunks of it with
- * `git apply --cached --unidiff-zero` placed a kept insertion at its
- * new-side line number once a dropped hunk above had shifted the file, and
- * an invalid manifest was committed. This command builds the staged
- * manifest from HEAD's rows plus the named working rows (see
- * `core/patch-manifest-stage.ts`), validates it, and writes it straight to
- * the index with `git hash-object` + `git update-index`. The working copy
- * is never touched, and nothing is committed.
- */
-import { Command } from 'commander';
-import type { CommandContext } from '../../types/cli.js';
-import type { PatchStageOptions } from '../../types/commands/index.js';
-/**
- * Runs the `patch stage` command.
- *
- * @param projectRoot - Project root directory (a git working tree)
- * @param identifiers - Patch filenames, ordinals or names to stage
- * @param options - Command options
- */
-export declare function patchStageCommand(projectRoot: string, identifiers: readonly string[], options?: PatchStageOptions): Promise<void>;
-/**
- * Registers the `patch stage` subcommand on the `patch` parent.
- *
- * @param parent - Parent Commander command
- * @param context - Shared CLI registration context
- */
-export declare function registerPatchStage(parent: Command, context: CommandContext): void;

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

@@ -1,153 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * `fireforge patch stage <name>...`: stages the named patches' `.patch`
- * files and only their rows of `patches/patches.json` in the project
- * repository's git index.
- *
- * The case it exists for: several sessions edit one checkout's queue, and
- * each must commit only its own patches. Staging the whole manifest takes
- * every session's rows; staging one owner's hunks of it with
- * `git apply --cached --unidiff-zero` placed a kept insertion at its
- * new-side line number once a dropped hunk above had shifted the file, and
- * an invalid manifest was committed. This command builds the staged
- * manifest from HEAD's rows plus the named working rows (see
- * `core/patch-manifest-stage.ts`), validates it, and writes it straight to
- * the index with `git hash-object` + `git update-index`. The working copy
- * is never touched, and nothing is committed.
- */
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join, relative, sep } from 'node:path';
-import { Command } from 'commander';
-import { getProjectPaths } from '../../core/config.js';
-import { git } from '../../core/git-base.js';
-import { withPatchDirectoryLock } from '../../core/patch-lock.js';
-import { loadPatchesManifestForWrite, resolvePatchIdentifier, validatePatchesManifest, } from '../../core/patch-manifest.js';
-import { mergeStagedManifest, serializeStagedManifest, } from '../../core/patch-manifest-stage.js';
-import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
-import { toError } from '../../utils/errors.js';
-import { pathExists } from '../../utils/fs.js';
-import { info, intro, outro } from '../../utils/logger.js';
-import { addWaitLockOption, pickDefined, resolveWaitLockSeconds } from '../../utils/options.js';
-import { exec } from '../../utils/process.js';
-/** A project-relative path in git's separator. */
-function gitPath(projectRoot, path) {
-    return relative(projectRoot, path).split(sep).join('/');
-}
-/** HEAD's manifest, or null when HEAD has none (or there is no HEAD yet). */
-async function readHeadManifest(projectRoot, manifestPath) {
-    const shown = await exec('git', ['show', `HEAD:./${manifestPath}`], { cwd: projectRoot });
-    if (shown.exitCode !== 0)
-        return null;
-    try {
-        return validatePatchesManifest(JSON.parse(shown.stdout));
-    }
-    catch (error) {
-        throw new GeneralError(`HEAD's ${manifestPath} is not a valid manifest (${toError(error).message}); stage it by hand.`);
-    }
-}
-/** Resolves each identifier to a filename, against the working rows then HEAD's. */
-function resolveFilenames(identifiers, working, head) {
-    const filenames = new Set();
-    for (const identifier of identifiers) {
-        const live = resolvePatchIdentifier(identifier, working.patches);
-        // A patch deleted (or renamed away) in the working copy is named by its
-        // HEAD filename, so its row can be staged as removed.
-        const gone = (head?.patches ?? []).find((row) => row.filename === identifier || row.filename === `${identifier}.patch`);
-        const filename = live?.filename ?? gone?.filename;
-        if (filename === undefined) {
-            throw new InvalidArgumentError(`No patch "${identifier}" in the working manifest or at HEAD.`, identifier);
-        }
-        filenames.add(filename);
-    }
-    return filenames;
-}
-/** Stages one `.patch` file: its content, or its removal when it is gone. */
-async function stagePatchFile(projectRoot, patchPath) {
-    if (await pathExists(join(projectRoot, patchPath))) {
-        await git(['add', '--', patchPath], projectRoot);
-        return;
-    }
-    const tracked = await exec('git', ['ls-files', '--error-unmatch', '--', patchPath], {
-        cwd: projectRoot,
-    });
-    if (tracked.exitCode === 0) {
-        await git(['rm', '--cached', '--quiet', '--', patchPath], projectRoot);
-    }
-}
-/** Writes `content` as a blob and points the index entry at it. */
-async function stageBlob(projectRoot, path, content) {
-    const scratch = await mkdtemp(join(tmpdir(), 'fireforge-stage-'));
-    try {
-        const file = join(scratch, 'patches.json');
-        await writeFile(file, content);
-        const sha = (await git(['hash-object', '-w', '--no-filters', file], projectRoot)).trim();
-        await git(['update-index', '--add', '--cacheinfo', `100644,${sha},${path}`], projectRoot);
-    }
-    finally {
-        await rm(scratch, { recursive: true, force: true });
-    }
-}
-/**
- * Runs the `patch stage` command.
- *
- * @param projectRoot - Project root directory (a git working tree)
- * @param identifiers - Patch filenames, ordinals or names to stage
- * @param options - Command options
- */
-export async function patchStageCommand(projectRoot, identifiers, options = {}) {
-    intro(options.dryRun ? 'FireForge patch stage (dry run)' : 'FireForge patch stage');
-    const probe = await exec('git', ['rev-parse', '--is-inside-work-tree'], { cwd: projectRoot });
-    if (probe.exitCode !== 0 || probe.stdout.trim() !== 'true') {
-        throw new GeneralError('patch stage needs the project to be a git working tree.');
-    }
-    const { patches: patchesDir } = getProjectPaths(projectRoot);
-    const manifestPath = gitPath(projectRoot, join(patchesDir, 'patches.json'));
-    // Under the patch lock, so the rows and `.patch` files staged are one
-    // consistent snapshot rather than a peer's half-finished write.
-    await withPatchDirectoryLock(patchesDir, async () => {
-        const working = await loadPatchesManifestForWrite(patchesDir);
-        if (working === null) {
-            throw new GeneralError(`No ${manifestPath} to stage.`);
-        }
-        const head = await readHeadManifest(projectRoot, manifestPath);
-        const filenames = resolveFilenames(identifiers, working, head);
-        let staged;
-        try {
-            staged = mergeStagedManifest(head, working, filenames);
-        }
-        catch (error) {
-            throw new GeneralError(`Refusing to stage: ${toError(error).message}.`);
-        }
-        const prefix = options.dryRun === true ? '[dry-run] ' : '';
-        for (const { filename, change } of staged.changes) {
-            info(`${prefix}${filename}: row ${change}; .patch file staged`);
-        }
-        if (options.dryRun === true)
-            return;
-        await stageBlob(projectRoot, manifestPath, serializeStagedManifest(staged.manifest));
-        for (const filename of filenames) {
-            await stagePatchFile(projectRoot, gitPath(projectRoot, join(patchesDir, filename)));
-        }
-        info(`Staged ${filenames.size} patch(es) and their ${manifestPath} rows. Other rows stay as at HEAD; ` +
-            'nothing was committed.');
-    }, { waitLockSeconds: resolveWaitLockSeconds(options.waitLock), command: 'patch stage' });
-    outro(options.dryRun ? 'Dry run complete — nothing staged' : 'Patch stage complete');
-}
-/**
- * Registers the `patch stage` subcommand on the `patch` parent.
- *
- * @param parent - Parent Commander command
- * @param context - Shared CLI registration context
- */
-export function registerPatchStage(parent, context) {
-    const { getProjectRoot, withErrorHandling } = context;
-    const command = parent
-        .command('stage <names...>')
-        .description("Stage the named patches' .patch files and only their patches.json rows in the git index " +
-        "(HEAD's rows for every other patch); validates the staged manifest, commits nothing")
-        .option('--dry-run', 'Show which rows would be staged without touching the index');
-    addWaitLockOption(command).action(withErrorHandling(async (names, options) => {
-        await patchStageCommand(getProjectRoot(), names, pickDefined(options));
-    }));
-}

package/dist/src/commands/patch/staged-dependency-batch.d.ts

@@ -1,48 +0,0 @@
-/**
- * Batch input and history delta for `patch staged-dependency`.
- *
- * `--from <json-file>` lets one `--add` call declare many edges under one
- * lock hold. Turning on `patchLint.forwardRegistration: "extended"` on a real
- * queue surfaced hundreds of undeclared registrations, each printed with its
- * own command, and one call per edge was the only way to declare them. The
- * file is either a `lint --per-patch --report` JSON (its findings carry the
- * `stagedDeclarations` that discharge them) or a plain array of
- * declarations.
- *
- * The history record of every call holds only the delta (`added` /
- * `removed`). Recording the patch's whole list before and after grew the
- * log quadratically with the list: 849 single-edge calls took one consumer's
- * log from 36 MB to 184 MB.
- */
-import type { PatchStagedDependencies, PatchStagedForwardImport, PatchStagedRegistration } from '../../types/commands/index.js';
-/** Declarations read from a `--from` file for one target patch. */
-export interface StagedDependencyBatch {
-    forwardImports: PatchStagedForwardImport[];
-    registrations: PatchStagedRegistration[];
-    /** Entries naming a different patch, left out. */
-    skippedForOtherPatches: number;
-}
-/**
- * Reads the declarations a `--from` file supplies for `targetFilename`.
- *
- * Every entry takes `file`, `creates`, optional `owner` and `reason`, and
- * either `specifier` (an import) or `line` (a registration); `kind` may
- * name the shape explicitly. An entry with a `patch` field naming another
- * patch is skipped and counted, so one report can be applied patch by
- * patch. `defaultReason` (the `--reason` flag) fills entries without one.
- *
- * @param path - The JSON file
- * @param targetFilename - Filename of the patch being edited
- * @param defaultReason - Reason for entries that carry none
- */
-export declare function readStagedDependencyBatch(path: string, targetFilename: string, defaultReason?: string): Promise<StagedDependencyBatch>;
-/**
- * The history delta between two committed `stagedDependencies` values:
- * the declarations the call added and the ones it removed. Each side is
- * omitted when empty. Older log records carry `before`/`after` instead;
- * a reader should accept either.
- */
-export declare function stagedDependencyDelta(before: PatchStagedDependencies | undefined, after: PatchStagedDependencies | undefined): {
-    added?: PatchStagedDependencies;
-    removed?: PatchStagedDependencies;
-};