@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/commands/status-check.js

@@ -1,161 +0,0 @@
-import { GeneralError, InvalidArgumentError } from '../errors/base.js';
-const ALL_CHECK_CLASSES = [
-    'patch-backed',
-    'patch-owned-drift',
-    'unmanaged',
-    'branding',
-    'furnace',
-    'conflict',
-    'binary-unsupported',
-    'ownership-conflict',
-];
-/**
- * Default `--check` policy: everything outside {patch-backed, branding,
- * furnace, binary-unsupported} fails. `binary-unsupported` is excluded so
- * an honest "cannot compare" does not keep the gate permanently red.
- * Strict CI can opt in via `--fail-on binary-unsupported`.
- * `ownership-conflict` is opt-in too: the human `--ownership` mode already
- * fails on it, and adding it here would change the default gate.
- */
-const DEFAULT_FAIL_CLASSIFICATIONS = [
-    'unmanaged',
-    'patch-owned-drift',
-    'conflict',
-];
-/**
- * Resolves the enforcement policy from the raw flags. `--fail-on`,
- * `--allow` and `--fail-on-unknown` each imply `--check`. `--fail-on`
- * replaces the default set and `--allow` subtracts from it (naming one
- * class in both is refused). `--fail-on-unknown` needs `--allow`: without
- * an allow list every class the caller did not name, `patch-backed`
- * included, would fail. All of them are refused alongside the modes that
- * skip (or elide) classification.
- */
-export function resolveStatusCheckPolicy(options) {
-    const failOnList = parseCheckClassList(options.failOn, '--fail-on');
-    const allowList = parseCheckClassList(options.allow, '--allow');
-    const failOnUnknown = options.failOnUnknown === true;
-    const checkEnabled = options.check === true || failOnList !== undefined || allowList !== undefined || failOnUnknown;
-    if (checkEnabled &&
-        (options.raw === true ||
-            options.unmanaged === true ||
-            options.ownership === true ||
-            options.testCoverage === true)) {
-        throw new InvalidArgumentError('--check cannot be combined with --raw, --unmanaged, --ownership, or --test-coverage. Use the default view or --json.', '--check');
-    }
-    if (failOnUnknown && allowList === undefined) {
-        throw new InvalidArgumentError('--fail-on-unknown requires --allow naming the classes that may pass. Without it every class you did not name, patch-backed included, would fail.', '--fail-on-unknown');
-    }
-    const overlap = (failOnList ?? []).filter((entry) => allowList?.includes(entry) === true);
-    if (overlap.length > 0) {
-        throw new InvalidArgumentError(`--fail-on and --allow both name ${overlap.join(', ')}. A class either fails or is allowed.`, '--allow');
-    }
-    const base = failOnList ?? DEFAULT_FAIL_CLASSIFICATIONS;
-    const policy = {
-        checkEnabled,
-        failOn: allowList ? base.filter((entry) => !allowList.includes(entry)) : base,
-    };
-    if (allowList !== undefined)
-        policy.allow = allowList;
-    if (failOnUnknown)
-        policy.failOnUnknown = true;
-    return policy;
-}
-function isCheckClass(value) {
-    return ALL_CHECK_CLASSES.includes(value);
-}
-/**
- * Parses a comma-separated `--fail-on`/`--allow` value into a class list.
- * Returns undefined when the flag was not given.
- */
-function parseCheckClassList(raw, flag) {
-    if (raw === undefined)
-        return undefined;
-    const parts = raw
-        .split(',')
-        .map((part) => part.trim())
-        .filter((part) => part.length > 0);
-    if (parts.length === 0) {
-        throw new InvalidArgumentError(`${flag} requires at least one classification. Valid: ${ALL_CHECK_CLASSES.join(', ')}.`, flag);
-    }
-    const classes = [];
-    for (const part of parts) {
-        if (!isCheckClass(part)) {
-            throw new InvalidArgumentError(`Unknown ${flag} classification "${part}". Valid: ${ALL_CHECK_CLASSES.join(', ')}.`, flag);
-        }
-        if (!classes.includes(part))
-            classes.push(part);
-    }
-    return classes;
-}
-/**
- * True when the policy can fail on `ownership-conflict`, so the caller has
- * to build the ownership rows even without `--include-ownership`.
- */
-export function policyNeedsOwnership(policy) {
-    if (!policy.checkEnabled)
-        return false;
-    if (policy.failOn.includes('ownership-conflict'))
-        return true;
-    return policy.failOnUnknown === true && policy.allow?.includes('ownership-conflict') !== true;
-}
-const CHECK_FILE_PREVIEW_MAX = 3;
-/**
- * Collects the failing classes that have offending files, with full file
- * lists: the fail set in policy order, then (under `--fail-on-unknown`)
- * every other present class neither list names, in first-seen order.
- * Shared by the human `--check` verdict and the JSON `check` block so the
- * two views can never disagree about what failed.
- *
- * @param classified - Classified worktree entries
- * @param policy - Resolved policy
- * @param ownershipConflicts - Paths claimed by more than one patch. Only
- *   read for the `ownership-conflict` class
- */
-export function collectStatusCheckOffenders(classified, policy, ownershipConflicts = []) {
-    const filesOf = (checkClass) => checkClass === 'ownership-conflict'
-        ? [...ownershipConflicts]
-        : classified.filter((entry) => entry.classification === checkClass).map((e) => e.file);
-    const offenders = [];
-    for (const checkClass of policy.failOn) {
-        const files = filesOf(checkClass);
-        if (files.length === 0)
-            continue;
-        offenders.push({ classification: checkClass, count: files.length, files });
-    }
-    if (policy.failOnUnknown !== true)
-        return offenders;
-    const named = new Set([...policy.failOn, ...(policy.allow ?? [])]);
-    const present = [...new Set(classified.map((e) => e.classification))];
-    if (ownershipConflicts.length > 0)
-        present.push('ownership-conflict');
-    for (const checkClass of present) {
-        if (named.has(checkClass))
-            continue;
-        const files = filesOf(checkClass);
-        offenders.push({ classification: checkClass, count: files.length, files, unnamed: true });
-    }
-    return offenders;
-}
-/**
- * Throws a GeneralError (exit 1) when the policy is enabled and any
- * failing class is non-empty, naming each offending class with its first
- * few files. A disabled policy or a fully tool-covered tree passes
- * silently.
- */
-export function runStatusCheck(classified, policy, ownershipConflicts = []) {
-    if (!policy.checkEnabled)
-        return;
-    const offending = collectStatusCheckOffenders(classified, policy, ownershipConflicts).map((offender) => {
-        const preview = offender.files.slice(0, CHECK_FILE_PREVIEW_MAX).join(', ');
-        const more = offender.count > CHECK_FILE_PREVIEW_MAX
-            ? `, +${offender.count - CHECK_FILE_PREVIEW_MAX} more`
-            : '';
-        const unnamed = offender.unnamed === true ? ' [named by neither --fail-on nor --allow]' : '';
-        return `${offender.count} ${offender.classification}${unnamed} (${preview}${more})`;
-    });
-    if (offending.length === 0)
-        return;
-    throw new GeneralError(`status --check failed: ${offending.join(', ')}. Export or adopt unmanaged files, ` +
-        `re-export drifted patches, and run "fireforge verify" for conflict details.`);
-}

package/dist/src/commands/status-json.d.ts

@@ -1,45 +0,0 @@
-/**
- * `status --json` payload rendering (schemaVersion 1). Helper module
- * consumed by status.ts (which sits at the max-lines budget). No top-level
- * registrar is exported and none is wanted.
- *
- * Two shapes share one counting pass:
- * - the full payload (`renderJsonStatus`) with the per-file `files[]` list,
- * - the `--summary` gate payload (`renderJsonSummaryStatus`), which omits
- *   `files[]` entirely, because engine-clean gates need the verdict,
- *   per-class counts, and offender names, not a payload that grows with
- *   the queue (175 KB+ on a large one).
- *
- * Both carry the `check` block when the `--check` policy is active, and the
- * `scope` block under `--patches`.
- */
-import type { ClassifiedFile } from '../core/status-classify.js';
-import { type StatusCheckPolicy } from './status-check.js';
-import type { OwnershipJsonBlock } from './status-ownership.js';
-import type { StatusScope } from './status-scope.js';
-/** What a JSON payload adds beside the classification counts. */
-export interface StatusJsonContext {
-    policy: StatusCheckPolicy;
-    /** Paths claimed by more than one patch, for the `ownership-conflict` class. */
-    ownershipConflicts: readonly string[];
-    /** The `--include-ownership` block, when asked for. */
-    ownership?: OwnershipJsonBlock | undefined;
-    /** The `--patches` scope, when given. */
-    scope?: StatusScope | undefined;
-}
-/**
- * Full `--json` payload: summary plus the per-file `files[]` list, and the
- * additive `check`, `scope` and `ownership` blocks when their flags are
- * set. Additive within schemaVersion 1: a consumer that does not ask for a
- * block never sees the key.
- */
-export declare function renderJsonStatus(classified: readonly ClassifiedFile[], context: StatusJsonContext): void;
-/**
- * Summary-only `--json --summary` payload. Counts are always present. When
- * the `--check`/`--fail-on` policy is active, the payload adds a `check`
- * block with the active fail set, the verdict, and the offending files per
- * failing class (sourced from the same collector as the human `--check`
- * message, so the two views can never disagree). The absent `files[]` is
- * the mode signal within schemaVersion 1. Consumers opt in via the flag.
- */
-export declare function renderJsonSummaryStatus(classified: readonly ClassifiedFile[], context: StatusJsonContext): void;

package/dist/src/commands/status-json.js

@@ -1,97 +0,0 @@
-import { setStdoutSealed } from '../utils/logger.js';
-import { collectStatusCheckOffenders, } from './status-check.js';
-function countByClassification(classified) {
-    const byClassification = {
-        unmanaged: 0,
-        'patch-owned-drift': 0,
-        'patch-backed': 0,
-        branding: 0,
-        furnace: 0,
-        conflict: 0,
-        'binary-unsupported': 0,
-    };
-    for (const file of classified) {
-        byClassification[file.classification]++;
-    }
-    return byClassification;
-}
-/**
- * Builds the `check` block, or undefined when no policy is active.
- * `allow` and `failOnUnknown` appear only when the caller set them, so a
- * consumer that never passes those flags sees the block it always did.
- */
-function buildCheckBlock(classified, context) {
-    const { policy } = context;
-    if (!policy.checkEnabled)
-        return undefined;
-    const offenders = collectStatusCheckOffenders(classified, policy, context.ownershipConflicts);
-    return {
-        enabled: true,
-        failOn: policy.failOn,
-        ...(policy.allow !== undefined ? { allow: policy.allow } : {}),
-        ...(policy.failOnUnknown === true ? { failOnUnknown: true } : {}),
-        failed: offenders.length > 0,
-        offenders,
-    };
-}
-/** The additive tail both payloads share: check, scope, ownership. */
-function buildTrailingBlocks(classified, context) {
-    const check = buildCheckBlock(classified, context);
-    return {
-        ...(check !== undefined ? { check } : {}),
-        ...(context.scope !== undefined ? { scope: context.scope } : {}),
-        ...(context.ownership !== undefined ? { ownership: context.ownership } : {}),
-    };
-}
-function writePayload(output) {
-    process.stdout.write(JSON.stringify(output, null, 2) + '\n');
-    // Payload written: stdout is now spoken for. See docs/machine-output.md.
-    setStdoutSealed(true);
-}
-/**
- * Full `--json` payload: summary plus the per-file `files[]` list, and the
- * additive `check`, `scope` and `ownership` blocks when their flags are
- * set. Additive within schemaVersion 1: a consumer that does not ask for a
- * block never sees the key.
- */
-export function renderJsonStatus(classified, context) {
-    const outputFiles = classified.map((f) => {
-        const entry = {
-            file: f.file,
-            status: f.status.trim(),
-            classification: f.classification,
-            patch: f.owner ?? null,
-        };
-        if (f.classification === 'conflict' && f.claimedBy && f.claimedBy.length > 0) {
-            entry.claimedBy = [...f.claimedBy];
-        }
-        return entry;
-    });
-    writePayload({
-        schemaVersion: 1,
-        summary: {
-            total: outputFiles.length,
-            byClassification: countByClassification(classified),
-        },
-        files: outputFiles,
-        ...buildTrailingBlocks(classified, context),
-    });
-}
-/**
- * Summary-only `--json --summary` payload. Counts are always present. When
- * the `--check`/`--fail-on` policy is active, the payload adds a `check`
- * block with the active fail set, the verdict, and the offending files per
- * failing class (sourced from the same collector as the human `--check`
- * message, so the two views can never disagree). The absent `files[]` is
- * the mode signal within schemaVersion 1. Consumers opt in via the flag.
- */
-export function renderJsonSummaryStatus(classified, context) {
-    writePayload({
-        schemaVersion: 1,
-        summary: {
-            total: classified.length,
-            byClassification: countByClassification(classified),
-        },
-        ...buildTrailingBlocks(classified, context),
-    });
-}

package/dist/src/commands/status-output.d.ts

@@ -1,23 +0,0 @@
-import type { BuildBaseline } from '../core/build-baseline-types.js';
-import type { ClassifiedFile } from '../core/status-classify.js';
-export interface ClassifiedBuckets {
-    conflict: ClassifiedFile[];
-    unmanaged: ClassifiedFile[];
-    patchBacked: ClassifiedFile[];
-    patchOwnedDrift: ClassifiedFile[];
-    branding: ClassifiedFile[];
-    furnace: ClassifiedFile[];
-    binaryUnsupported: ClassifiedFile[];
-}
-/** Renders the unmanaged-only status view and registration hints. */
-export declare function renderUnmanagedOnly(unmanagedFiles: ClassifiedFile[], totalModified: number, projectRoot: string, binaryName: string): Promise<void>;
-/** Renders the default classified status buckets. */
-export declare function renderDefaultStatus(totalModified: number, buckets: ClassifiedBuckets, projectRoot: string, binaryName: string): Promise<void>;
-/**
- * Renders `fireforge status --test-coverage`: a read-only view of the last
- * build baseline's test-packaging coverage. Without it, the only way to
- * learn the recorded coverage scope (which concurrent sessions sharing one
- * engine tree overwrite constantly) is to trip the out-of-coverage refusal
- * on a real test run.
- */
-export declare function renderTestCoverageStatus(baseline: BuildBaseline | undefined): void;

package/dist/src/commands/status-output.js

@@ -1,231 +0,0 @@
-import { isFileRegistered, matchesRegistrablePattern } from '../core/moz-manifest-rules.js';
-import { getPrimaryStatusCode } from '../core/status-classify.js';
-import { GeneralError } from '../errors/base.js';
-import { info, outro, warn } from '../utils/logger.js';
-const STATUS_DESCRIPTIONS = {
-    M: 'modified',
-    A: 'added',
-    D: 'deleted',
-    R: 'renamed',
-    C: 'copied',
-    U: 'unmerged',
-    '?': 'untracked',
-    '!': 'ignored',
-};
-function getStatusDescription(code) {
-    return STATUS_DESCRIPTIONS[code] ?? 'changed';
-}
-function isNewFileStatus(status) {
-    const code = getPrimaryStatusCode(status);
-    return code === '?' || code === 'A';
-}
-function groupFilesByStatus(files) {
-    const grouped = new Map();
-    for (const { status, file } of files) {
-        const code = getPrimaryStatusCode(status);
-        const existing = grouped.get(code) ?? [];
-        existing.push(file);
-        grouped.set(code, existing);
-    }
-    return grouped;
-}
-function printStatusGroups(files) {
-    const grouped = groupFilesByStatus(files);
-    for (const [status, fileList] of grouped) {
-        warn(`${getStatusDescription(status)}:`);
-        for (const file of fileList)
-            info(`  ${file}`);
-    }
-}
-async function printUnregisteredWarnings(files, projectRoot, binaryName) {
-    const newFiles = files.filter((f) => isNewFileStatus(f.status));
-    if (newFiles.length === 0)
-        return;
-    const registrableFiles = newFiles.filter((f) => matchesRegistrablePattern(f.file, binaryName));
-    const registrationChecks = await Promise.all(registrableFiles.map(async (f) => {
-        try {
-            return {
-                file: f.file,
-                registered: await isFileRegistered(projectRoot, f.file),
-                manifestMissing: false,
-                manifestMissingMessage: undefined,
-            };
-        }
-        catch (err) {
-            if (err instanceof GeneralError && /^Manifest not found:/i.test(err.message)) {
-                return {
-                    file: f.file,
-                    registered: false,
-                    manifestMissing: true,
-                    manifestMissingMessage: err.message,
-                };
-            }
-            throw err;
-        }
-    }));
-    const unregistered = registrationChecks.filter((f) => !f.registered && !f.manifestMissing);
-    const manifestMissing = registrationChecks.filter((f) => f.manifestMissing);
-    if (unregistered.length > 0) {
-        info('');
-        warn('Potentially unregistered files:');
-        for (const f of unregistered)
-            info(`  ${f.file} — run 'fireforge register ${f.file}'`);
-    }
-    if (manifestMissing.length > 0) {
-        info('');
-        warn('Files whose registration manifest does not exist yet:');
-        for (const f of manifestMissing) {
-            info(`  ${f.file} — ${f.manifestMissingMessage}`);
-            info(`    Create the parent manifest, then run 'fireforge register ${f.file}'.`);
-        }
-    }
-}
-/** Renders the unmanaged-only status view and registration hints. */
-export async function renderUnmanagedOnly(unmanagedFiles, totalModified, projectRoot, binaryName) {
-    info(`${unmanagedFiles.length} unmanaged file${unmanagedFiles.length === 1 ? '' : 's'} (${totalModified} total modified):\n`);
-    if (unmanagedFiles.length > 0) {
-        printStatusGroups(unmanagedFiles);
-        await printUnregisteredWarnings(unmanagedFiles, projectRoot, binaryName);
-    }
-    else {
-        info('No unmanaged changes');
-    }
-    outro(unmanagedFiles.length === 0
-        ? 'No unmanaged changes'
-        : `${unmanagedFiles.length} unmanaged change${unmanagedFiles.length === 1 ? '' : 's'}`);
-}
-/** Renders the cross-patch ownership conflict section. */
-function renderConflictSection(conflict) {
-    warn('Cross-patch ownership conflicts (same file claimed by multiple patches):');
-    printStatusGroups(conflict);
-    for (const entry of conflict) {
-        if (entry.claimedBy && entry.claimedBy.length > 0) {
-            info(`  ${entry.file} — claimed by ${entry.claimedBy.join(', ')}`);
-        }
-    }
-    info('Run "fireforge status --ownership" for the full conflict table, then repartition with "fireforge re-export --files <paths> <patch>".');
-}
-/** Renders the default classified status buckets. */
-export async function renderDefaultStatus(totalModified, buckets, projectRoot, binaryName) {
-    const { conflict, unmanaged, patchBacked, patchOwnedDrift, branding, furnace, binaryUnsupported, } = buckets;
-    info(`${totalModified} modified file${totalModified === 1 ? '' : 's'}:\n`);
-    // Sections render in this fixed order, separated by a blank line
-    // whenever an earlier section already printed (the pre-refactor code
-    // expressed the same rule as per-section "any earlier bucket
-    // non-empty" conditions).
-    const sections = [
-        {
-            files: conflict,
-            label: 'conflict',
-            render: () => {
-                renderConflictSection(conflict);
-            },
-        },
-        {
-            files: unmanaged,
-            label: 'unmanaged',
-            render: async () => {
-                warn('Unmanaged changes:');
-                printStatusGroups(unmanaged);
-                await printUnregisteredWarnings(unmanaged, projectRoot, binaryName);
-            },
-        },
-        {
-            files: patchBacked,
-            label: 'patch-backed',
-            render: () => {
-                warn('Patch-backed materialized changes:');
-                printStatusGroups(patchBacked);
-            },
-        },
-        {
-            files: patchOwnedDrift,
-            label: 'patch-owned drift',
-            render: () => {
-                warn('Patch-owned drift:');
-                printStatusGroups(patchOwnedDrift);
-                info('These files are claimed by exactly one patch, but engine/ no longer matches that patch output. Re-export the owning patch after reviewing the manual resolution.');
-            },
-        },
-        {
-            files: branding,
-            label: 'branding',
-            render: () => {
-                warn('Tool-managed branding changes:');
-                printStatusGroups(branding);
-            },
-        },
-        {
-            files: furnace,
-            label: 'furnace',
-            render: () => {
-                warn('Furnace-managed component changes:');
-                printStatusGroups(furnace);
-            },
-        },
-        {
-            files: binaryUnsupported,
-            label: 'binary — comparison unsupported',
-            render: () => {
-                warn('Binary — comparison unsupported:');
-                printStatusGroups(binaryUnsupported);
-                info('These patch-owned binary files carry no comparable blob hash in their patch body, so durability cannot be verified. Re-export the owning patch with a git binary body to make them comparable.');
-            },
-        },
-    ];
-    let printedAny = false;
-    for (const section of sections) {
-        if (section.files.length === 0)
-            continue;
-        if (printedAny)
-            info('');
-        await section.render();
-        printedAny = true;
-    }
-    if (!printedAny) {
-        info('No changes');
-    }
-    const parts = sections
-        .filter((section) => section.files.length > 0)
-        .map((section) => `${section.files.length} ${section.label}`);
-    outro(parts.join(', '));
-}
-/**
- * Renders `fireforge status --test-coverage`: a read-only view of the last
- * build baseline's test-packaging coverage. Without it, the only way to
- * learn the recorded coverage scope (which concurrent sessions sharing one
- * engine tree overwrite constantly) is to trip the out-of-coverage refusal
- * on a real test run.
- */
-export function renderTestCoverageStatus(baseline) {
-    if (baseline === undefined) {
-        info('No build baseline recorded (.fireforge/last-build.json missing or unreadable).\n' +
-            'Run "fireforge build" to record one.');
-        outro('No test-packaging coverage recorded');
-        return;
-    }
-    info(`Last build: ${baseline.builtAt}  (binary: ${baseline.binaryName}, ` +
-        `engine HEAD: ${baseline.engineHeadSha || '(unborn)'})`);
-    const recorder = baseline.recorder;
-    info(`Recorded by: ${baseline.recordedBy ?? 'unknown'}` +
-        (recorder === undefined
-            ? ''
-            : ` (pid ${recorder.pid}${recorder.sessionId !== undefined ? `, session ${recorder.sessionId}` : ''})`));
-    const coverage = baseline.testPackagingCoverage;
-    if (coverage === undefined) {
-        info('Test packaging coverage: full (implicit — baseline predates coverage recording)');
-        outro('Coverage: full');
-        return;
-    }
-    if (coverage === 'full') {
-        info('Test packaging coverage: full');
-        outro('Coverage: full');
-        return;
-    }
-    const list = coverage.map((path) => `  - ${path}`).join('\n');
-    info(`Test packaging coverage: scoped to ${coverage.length} path(s):\n${list}\n` +
-        (baseline.fullCoverageAnchor === undefined
-            ? 'A "fireforge test" over paths outside this list will be refused as uncovered.'
-            : 'A "fireforge test" over paths outside this list stays covered by the earlier full build while their own staging inputs are unchanged, and is refused otherwise.'));
-    outro(`Coverage: scoped (${coverage.length} paths)`);
-}

package/dist/src/commands/status-ownership.d.ts

@@ -1,54 +0,0 @@
-/**
- * Ownership-table assembly for `status`, split out of `status.ts` so the
- * human `--ownership` mode and the additive `ownership` block on the
- * `--json` payload build the same rows from the same scan.
- *
- * A separate `--ownership` branch re-implements the shared scan and inlines
- * a second copy of the classification call, then discards everything but
- * each file's classification, so three back-to-back `status` invocations in
- * a gate pay three full worktree scans. Both callers hand this module the
- * already-classified files instead.
- *
- * No renderer lives here: `renderOwnershipTable` (human) and the JSON
- * serializer stay with their respective output layers.
- */
-import type { OwnershipRow } from '../core/ownership-table.js';
-import type { ClassifiedFile, StatusFile } from '../core/status-classify.js';
-import type { PatchMetadata } from '../types/commands/index.js';
-/** Counts the human outro prints and the JSON block carries. */
-export interface OwnershipSummary {
-    managed: number;
-    unmanaged: number;
-    conflicts: number;
-}
-/** The additive `ownership` block on the schemaVersion-1 JSON payload. */
-export interface OwnershipJsonBlock {
-    rows: OwnershipRow[];
-    summary: OwnershipSummary;
-}
-/**
- * Builds the flat path→owning-patch rows. Sources are the manifest's
- * `filesAffected`, worktree drift, and the cross-patch
- * duplicate-new-file-creation map produced by walking each patch body, the
- * last being what keeps `status --ownership` aligned with `fireforge verify`
- * (see `buildOwnershipTable`'s header).
- *
- * @param patchesDir - Absolute path to the patches directory
- * @param manifestPatches - Manifest rows, each with its `filesAffected`
- * @param files - Raw worktree status entries
- * @param classified - The same entries, already classified
- * @returns The flat ownership rows
- */
-export declare function collectOwnershipRows(patchesDir: string, manifestPatches: readonly PatchMetadata[], files: StatusFile[], classified: readonly ClassifiedFile[]): Promise<OwnershipRow[]>;
-/**
- * Counts managed / unmanaged / conflicted rows. Conflicts are rows flagged
- * `conflict`, not a separate collection.
- * @param rows - Rows from {@link collectOwnershipRows}
- */
-export declare function summarizeOwnership(rows: readonly OwnershipRow[]): OwnershipSummary;
-/**
- * Assembles the JSON block. Rows are carried verbatim so the machine shape
- * and the rendered table can never disagree.
- * @param rows - Rows from {@link collectOwnershipRows}
- */
-export declare function buildOwnershipJsonBlock(rows: OwnershipRow[]): OwnershipJsonBlock;

package/dist/src/commands/status-ownership.js

@@ -1,59 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Ownership-table assembly for `status`, split out of `status.ts` so the
- * human `--ownership` mode and the additive `ownership` block on the
- * `--json` payload build the same rows from the same scan.
- *
- * A separate `--ownership` branch re-implements the shared scan and inlines
- * a second copy of the classification call, then discards everything but
- * each file's classification, so three back-to-back `status` invocations in
- * a gate pay three full worktree scans. Both callers hand this module the
- * already-classified files instead.
- *
- * No renderer lives here: `renderOwnershipTable` (human) and the JSON
- * serializer stay with their respective output layers.
- */
-import { buildOwnershipTable } from '../core/ownership-table.js';
-import { buildPatchQueueContext, collectNewFileCreatorsByPath } from '../core/patch-lint.js';
-import { pathExists } from '../utils/fs.js';
-/**
- * Builds the flat path→owning-patch rows. Sources are the manifest's
- * `filesAffected`, worktree drift, and the cross-patch
- * duplicate-new-file-creation map produced by walking each patch body, the
- * last being what keeps `status --ownership` aligned with `fireforge verify`
- * (see `buildOwnershipTable`'s header).
- *
- * @param patchesDir - Absolute path to the patches directory
- * @param manifestPatches - Manifest rows, each with its `filesAffected`
- * @param files - Raw worktree status entries
- * @param classified - The same entries, already classified
- * @returns The flat ownership rows
- */
-export async function collectOwnershipRows(patchesDir, manifestPatches, files, classified) {
-    // Only walk patch bodies when the directory actually exists: a fresh
-    // project with no queue degrades to filesAffected-only behavior.
-    const newFileCreatorsByPath = (await pathExists(patchesDir))
-        ? collectNewFileCreatorsByPath(await buildPatchQueueContext(patchesDir))
-        : new Map();
-    return buildOwnershipTable([...manifestPatches], files, newFileCreatorsByPath, new Map(classified.map((entry) => [entry.file, entry.classification])));
-}
-/**
- * Counts managed / unmanaged / conflicted rows. Conflicts are rows flagged
- * `conflict`, not a separate collection.
- * @param rows - Rows from {@link collectOwnershipRows}
- */
-export function summarizeOwnership(rows) {
-    return {
-        managed: rows.filter((r) => !r.unmanaged).length,
-        unmanaged: rows.filter((r) => r.unmanaged).length,
-        conflicts: rows.filter((r) => r.conflict).length,
-    };
-}
-/**
- * Assembles the JSON block. Rows are carried verbatim so the machine shape
- * and the rendered table can never disagree.
- * @param rows - Rows from {@link collectOwnershipRows}
- */
-export function buildOwnershipJsonBlock(rows) {
-    return { rows, summary: summarizeOwnership(rows) };
-}