@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/commands/patch/split-staged.d.ts

@@ -1,108 +0,0 @@
-/**
- * Staged-dependency upkeep for `patch split` and `patch move-files
- * --create`: the declarations a file move invalidates.
- *
- * Moving files into a new patch changes three kinds of declaration:
- *
- *  - an `owner` that named the source for a `creates` path that moved now
- *    names the new patch (both kinds, see {@link rewriteSplitOwners});
- *  - a declaration the source holds for a site in a moved file belongs to
- *    the new patch, because the importing or registering line moved with
- *    the file ({@link relocatedSourceDeclarations});
- *  - a declaration that was in use before the move and is not after it
- *    (the new patch now applies before the importer, or the importer and
- *    the imported file landed in one patch) is dropped
- *    ({@link findDeclarationsMadeUnused}).
- *
- * Without this the move would write the bodies and leave the queue audit
- * and the per-patch lint to report `queue-dependency-creates-unowned` and
- * `staged-dependency-unused` afterwards, one `--remove`/`--add` pair per
- * entry to repair by hand.
- */
-import type { PatchQueueEntry } from '../../core/patch-lint.js';
-import type { PatchLintIssue, PatchMetadata, PatchStagedDependencies, PatchStagedForwardImport, PatchStagedRegistration } from '../../types/commands/index.js';
-/** One declaration of either kind. */
-export type StagedDeclaration = PatchStagedForwardImport | PatchStagedRegistration;
-/** A declaration the move made unused, named by its post-move holder. */
-export interface DroppedStagedDeclaration {
-    /** Holder patch filename after the move (and any renumber). */
-    holder: string;
-    /** The declaration as the projected queue holds it. */
-    declaration: StagedDeclaration;
-}
-/** Declaration changes a split or `move-files --create` commits. */
-export interface SplitStagedMaintenance {
-    /** Source declarations whose declaring file moved, re-homed on the new patch. */
-    relocated: PatchStagedDependencies;
-    /** Declarations in use before the move and unused after it. */
-    dropped: DroppedStagedDeclaration[];
-}
-/** An empty maintenance plan. */
-export declare function emptyStagedMaintenance(): SplitStagedMaintenance;
-/**
- * The source's declarations whose declaring file moves, with owners passed
- * through `ownerLookup` (the renumber the placement implies).
- *
- * @param source - The source patch's current manifest row
- * @param movedSet - Files moving to the new patch
- * @param ownerLookup - Old → new filename for renumbered patches
- */
-export declare function relocatedSourceDeclarations(source: PatchMetadata, movedSet: ReadonlySet<string>, ownerLookup: (oldFilename: string) => string | undefined): PatchStagedDependencies;
-/**
- * Removes from the source row the declarations whose declaring file moved
- * (they are re-homed on the new patch).
- */
-export declare function withoutRelocatedDeclarations(source: PatchMetadata, movedSet: ReadonlySet<string>): PatchMetadata;
-/**
- * Re-points `owner` from the source to the new patch on every declaration
- * (forward-import and registration alike) whose `creates` path moved.
- */
-export declare function rewriteSplitOwners(patch: PatchMetadata, sourceFilename: string, movedSet: ReadonlySet<string>, newFilename: string): PatchMetadata;
-/**
- * Finds patches holding a declaration (either kind) whose `owner` is the
- * source patch and whose `creates` path moves to the new patch.
- */
-export declare function findOwnerRewriteHolders(patches: readonly PatchMetadata[], sourceFilename: string, movedSet: ReadonlySet<string>): string[];
-/** Inputs to {@link findDeclarationsMadeUnused}. */
-export interface MadeUnusedInput {
-    /** Queue entries before the move. */
-    baselineEntries: readonly PatchQueueEntry[];
-    /** Queue entries after the move, relocations and owner rewrites applied. */
-    projectedEntries: readonly PatchQueueEntry[];
-    /** Every finding of the baseline queue lint (all severities). */
-    baselineIssues: readonly PatchLintIssue[];
-    /** Every finding of the projected queue lint (all severities). */
-    projectedIssues: readonly PatchLintIssue[];
-    /** Source patch filename before the move. */
-    sourceFilename: string;
-    /** The new patch's filename. */
-    newFilename: string;
-    /** Projected → pre-move filename for renumbered patches. */
-    mapBack: (projectedFilename: string) => string;
-    /** Files moving to the new patch. */
-    movedSet: ReadonlySet<string>;
-}
-/**
- * Declarations the projected queue reports `staged-dependency-unused` for
- * that the baseline queue did not: the ones the move itself made unused.
- * Only declarations the move touches are candidates (their `creates` path
- * moved, or they were re-homed on the new patch), so pre-existing stale
- * declarations elsewhere are left for the operator.
- */
-export declare function findDeclarationsMadeUnused(input: MadeUnusedInput): DroppedStagedDeclaration[];
-/**
- * Removes the dropped declarations held by `patch` (matched by its
- * post-move filename and the declaration's projected identity).
- */
-export declare function withoutDroppedDeclarations(patch: PatchMetadata, dropped: readonly DroppedStagedDeclaration[]): PatchMetadata;
-/** The relocated declarations the new patch keeps (relocated minus dropped). */
-export declare function keptRelocatedDeclarations(maintenance: SplitStagedMaintenance, newFilename: string): PatchStagedDependencies;
-/**
- * Operator-facing lines naming every declaration the move re-homes or
- * drops. Empty when the move touches no declaration.
- *
- * @param maintenance - The planned changes
- * @param sourceFilename - Source patch filename
- * @param newFilename - The new patch's filename
- */
-export declare function describeStagedMaintenance(maintenance: SplitStagedMaintenance, sourceFilename: string, newFilename: string): string[];

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

@@ -1,202 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Staged-dependency upkeep for `patch split` and `patch move-files
- * --create`: the declarations a file move invalidates.
- *
- * Moving files into a new patch changes three kinds of declaration:
- *
- *  - an `owner` that named the source for a `creates` path that moved now
- *    names the new patch (both kinds, see {@link rewriteSplitOwners});
- *  - a declaration the source holds for a site in a moved file belongs to
- *    the new patch, because the importing or registering line moved with
- *    the file ({@link relocatedSourceDeclarations});
- *  - a declaration that was in use before the move and is not after it
- *    (the new patch now applies before the importer, or the importer and
- *    the imported file landed in one patch) is dropped
- *    ({@link findDeclarationsMadeUnused}).
- *
- * Without this the move would write the bodies and leave the queue audit
- * and the per-patch lint to report `queue-dependency-creates-unowned` and
- * `staged-dependency-unused` afterwards, one `--remove`/`--add` pair per
- * entry to repair by hand.
- */
-import { stagedDependencyUnusedFingerprint } from '../../core/patch-lint-staged-registration.js';
-/** An empty maintenance plan. */
-export function emptyStagedMaintenance() {
-    return { relocated: {}, dropped: [] };
-}
-function declarationsOf(staged) {
-    return [...(staged?.forwardImports ?? []), ...(staged?.registrations ?? [])];
-}
-function matcherOf(declaration) {
-    return 'specifier' in declaration ? `i:${declaration.specifier}` : `r:${declaration.line}`;
-}
-/** Identity of a declaration, owner included. */
-function declarationKey(declaration) {
-    return [
-        declaration.file,
-        matcherOf(declaration),
-        declaration.creates,
-        declaration.owner ?? '',
-    ].join('\0');
-}
-/** Identity without the owner, which a renumber or split may rewrite. */
-function declarationSiteKey(declaration) {
-    return [declaration.file, matcherOf(declaration), declaration.creates].join('\0');
-}
-function rebuildStaged(staged, keep, rewrite = (declaration) => declaration) {
-    const forwardImports = (staged?.forwardImports ?? [])
-        .filter(keep)
-        .map((entry) => rewrite(entry));
-    const registrations = (staged?.registrations ?? [])
-        .filter(keep)
-        .map((entry) => rewrite(entry));
-    return {
-        ...(forwardImports.length > 0 ? { forwardImports } : {}),
-        ...(registrations.length > 0 ? { registrations } : {}),
-    };
-}
-function hasDeclarations(staged) {
-    return declarationsOf(staged).length > 0;
-}
-/** Writes `staged` onto `patch`, dropping the field when it is empty. */
-function withStaged(patch, staged) {
-    if (hasDeclarations(staged))
-        return { ...patch, stagedDependencies: staged };
-    if (patch.stagedDependencies === undefined)
-        return patch;
-    const rest = { ...patch };
-    delete rest.stagedDependencies;
-    return rest;
-}
-/**
- * The source's declarations whose declaring file moves, with owners passed
- * through `ownerLookup` (the renumber the placement implies).
- *
- * @param source - The source patch's current manifest row
- * @param movedSet - Files moving to the new patch
- * @param ownerLookup - Old → new filename for renumbered patches
- */
-export function relocatedSourceDeclarations(source, movedSet, ownerLookup) {
-    return rebuildStaged(source.stagedDependencies, (declaration) => movedSet.has(declaration.file), (declaration) => {
-        const owner = declaration.owner === undefined ? undefined : ownerLookup(declaration.owner);
-        return owner === undefined ? { ...declaration } : { ...declaration, owner };
-    });
-}
-/**
- * Removes from the source row the declarations whose declaring file moved
- * (they are re-homed on the new patch).
- */
-export function withoutRelocatedDeclarations(source, movedSet) {
-    if (!declarationsOf(source.stagedDependencies).some((d) => movedSet.has(d.file)))
-        return source;
-    return withStaged(source, rebuildStaged(source.stagedDependencies, (declaration) => !movedSet.has(declaration.file)));
-}
-/**
- * Re-points `owner` from the source to the new patch on every declaration
- * (forward-import and registration alike) whose `creates` path moved.
- */
-export function rewriteSplitOwners(patch, sourceFilename, movedSet, newFilename) {
-    const matches = (declaration) => declaration.owner === sourceFilename && movedSet.has(declaration.creates);
-    if (!declarationsOf(patch.stagedDependencies).some(matches))
-        return patch;
-    return {
-        ...patch,
-        stagedDependencies: {
-            ...patch.stagedDependencies,
-            ...rebuildStaged(patch.stagedDependencies, () => true, (declaration) => matches(declaration) ? { ...declaration, owner: newFilename } : declaration),
-        },
-    };
-}
-/**
- * Finds patches holding a declaration (either kind) whose `owner` is the
- * source patch and whose `creates` path moves to the new patch.
- */
-export function findOwnerRewriteHolders(patches, sourceFilename, movedSet) {
-    return patches
-        .filter((patch) => declarationsOf(patch.stagedDependencies).some((declaration) => declaration.owner === sourceFilename && movedSet.has(declaration.creates)))
-        .map((patch) => patch.filename);
-}
-/**
- * Declarations the projected queue reports `staged-dependency-unused` for
- * that the baseline queue did not: the ones the move itself made unused.
- * Only declarations the move touches are candidates (their `creates` path
- * moved, or they were re-homed on the new patch), so pre-existing stale
- * declarations elsewhere are left for the operator.
- */
-export function findDeclarationsMadeUnused(input) {
-    const unusedFingerprints = (issues) => new Set(issues
-        .filter((issue) => issue.check === 'staged-dependency-unused')
-        .map((issue) => issue.fingerprint ?? ''));
-    const baselineUnused = unusedFingerprints(input.baselineIssues);
-    const projectedUnused = unusedFingerprints(input.projectedIssues);
-    const baselineByHolder = new Map(input.baselineEntries.map((entry) => [entry.filename, entry.metadata]));
-    const dropped = [];
-    for (const entry of input.projectedEntries) {
-        const isNewPatch = entry.filename === input.newFilename;
-        for (const declaration of declarationsOf(entry.metadata?.stagedDependencies)) {
-            if (!isNewPatch && !input.movedSet.has(declaration.creates))
-                continue;
-            if (!projectedUnused.has(stagedDependencyUnusedFingerprint(entry.filename, declaration))) {
-                continue;
-            }
-            const originalHolder = isNewPatch ? input.sourceFilename : input.mapBack(entry.filename);
-            const original = declarationsOf(baselineByHolder.get(originalHolder)?.stagedDependencies).find((candidate) => declarationSiteKey(candidate) === declarationSiteKey(declaration));
-            if (original !== undefined &&
-                baselineUnused.has(stagedDependencyUnusedFingerprint(originalHolder, original))) {
-                continue;
-            }
-            dropped.push({ holder: entry.filename, declaration });
-        }
-    }
-    return dropped;
-}
-/**
- * Removes the dropped declarations held by `patch` (matched by its
- * post-move filename and the declaration's projected identity).
- */
-export function withoutDroppedDeclarations(patch, dropped) {
-    const keys = new Set(dropped
-        .filter((entry) => entry.holder === patch.filename)
-        .map((entry) => declarationKey(entry.declaration)));
-    if (keys.size === 0)
-        return patch;
-    return withStaged(patch, rebuildStaged(patch.stagedDependencies, (declaration) => !keys.has(declarationKey(declaration))));
-}
-/** The relocated declarations the new patch keeps (relocated minus dropped). */
-export function keptRelocatedDeclarations(maintenance, newFilename) {
-    const keys = new Set(maintenance.dropped
-        .filter((entry) => entry.holder === newFilename)
-        .map((entry) => declarationKey(entry.declaration)));
-    return rebuildStaged(maintenance.relocated, (declaration) => !keys.has(declarationKey(declaration)));
-}
-function describeDeclaration(declaration) {
-    return 'specifier' in declaration
-        ? `${declaration.file} imports "${declaration.specifier}" (${declaration.creates})`
-        : `${declaration.file} registers "${declaration.line}" (${declaration.creates})`;
-}
-/**
- * Operator-facing lines naming every declaration the move re-homes or
- * drops. Empty when the move touches no declaration.
- *
- * @param maintenance - The planned changes
- * @param sourceFilename - Source patch filename
- * @param newFilename - The new patch's filename
- */
-export function describeStagedMaintenance(maintenance, sourceFilename, newFilename) {
-    const lines = [];
-    const kept = declarationsOf(keptRelocatedDeclarations(maintenance, newFilename));
-    if (kept.length > 0) {
-        lines.push(`staged-dependency declarations moved from ${sourceFilename} to ${newFilename} (${kept.length}):`);
-        for (const declaration of kept)
-            lines.push(`  ${describeDeclaration(declaration)}`);
-    }
-    if (maintenance.dropped.length > 0) {
-        lines.push(`staged-dependency declarations dropped because the move made them unused (${maintenance.dropped.length}):`);
-        for (const { holder, declaration } of maintenance.dropped) {
-            const shownHolder = holder === newFilename ? `${sourceFilename} → ${newFilename}` : holder;
-            lines.push(`  ${shownHolder}: ${describeDeclaration(declaration)}`);
-        }
-    }
-    return lines;
-}

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

@@ -1,43 +0,0 @@
-/**
- * `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 { Command } from 'commander';
-import type { CommandContext } from '../../types/cli.js';
-import type { PatchMetadata, PatchSplitOptions } from '../../types/commands/index.js';
-import type { FireForgeConfig } from '../../types/config.js';
-import { type SplitPlan } from './split-plan.js';
-/**
- * Prints the owner rewrites and the declarations the move re-homed or
- * dropped, after a committed split or `move-files --create`.
- */
-export declare function reportSplitStagedChanges(plan: SplitPlan): void;
-/**
- * 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 declare function commitPatchSplit(patchesDir: string, plan: SplitPlan, newMetadata: PatchMetadata, options: Pick<PatchSplitOptions, 'yes' | 'forceUnsafe' | 'waitLock'>, config: FireForgeConfig): Promise<void>;
-/**
- * Runs the `patch split` command: plans the split, lints the projection,
- * confirms, and commits transactionally.
- */
-export declare function patchSplitCommand(projectRoot: string, sourceId: string, options: PatchSplitOptions): Promise<void>;
-/**
- * Registers the `patch split` subcommand on the `patch` parent.
- */
-export declare function registerPatchSplit(parent: Command, context: CommandContext): void;