@hominis/fireforge 0.39.0 → 0.41.0

package/dist/src/commands/reset.js

@@ -2,12 +2,12 @@
 import { confirm } from '@clack/prompts';
 import { Command } from 'commander';
 import { getProjectPaths } from '../core/config.js';
+import { assertEngineGitReady } from '../core/engine-precondition.js';
 import { clearAppliedFurnaceState } from '../core/furnace-config.js';
-import { getHead, hasChanges, isGitRepository, isMissingHeadError, resetChanges, } from '../core/git.js';
+import { hasChanges, resetChanges } from '../core/git.js';
 import { expandUntrackedDirectoryEntries, getWorkingTreeStatus } from '../core/git-status.js';
 import { warnIfStaticComponentsStale } from '../core/test-stale-check.js';
-import { GeneralError, InvalidArgumentError } from '../errors/base.js';
-import { pathExists } from '../utils/fs.js';
+import { InvalidArgumentError } from '../errors/base.js';
 import { cancel, info, intro, isCancel, outro, spinner, warn } from '../utils/logger.js';
 import { pickDefined } from '../utils/options.js';
 /**
@@ -18,26 +18,7 @@ import { pickDefined } from '../utils/options.js';
 export async function resetCommand(projectRoot, options) {
     intro('FireForge Reset');
     const paths = getProjectPaths(projectRoot);
-    // Check if engine exists
-    if (!(await pathExists(paths.engine))) {
-        throw new GeneralError('Firefox source not found. Run "fireforge download" first.');
-    }
-    // Check if it's a git repository
-    if (!(await isGitRepository(paths.engine))) {
-        throw new GeneralError('Engine directory is not a git repository. Run "fireforge download" to initialize.');
-    }
-    // Unborn-HEAD guard (mirrors status): an interrupted download leaves a
-    // repo with no baseline commit, where the entire ~300k-file tree reads
-    // as untracked — a reset against that state is never what the operator
-    // wants, and the guidance names the actual fix.
-    try {
-        await getHead(paths.engine);
-    }
-    catch (headError) {
-        if (!isMissingHeadError(headError))
-            throw headError;
-        throw new GeneralError('Engine repository has no baseline commit yet — a previous "fireforge download" was interrupted before git created the initial Firefox source commit. Re-run "fireforge download --force" to recreate the baseline repository cleanly.');
-    }
+    await assertEngineGitReady(paths.engine);
     // Check for changes
     const hasUncommittedChanges = await hasChanges(paths.engine);
     if (!hasUncommittedChanges) {

package/dist/src/commands/resolve.js

@@ -3,7 +3,7 @@ import { join } from 'node:path';
 import { confirm } from '@clack/prompts';
 import { Command } from 'commander';
 import { getProjectPaths, loadConfig, loadState, updateState } from '../core/config.js';
-import { isGitRepository } from '../core/git.js';
+import { assertEngineGitReady } from '../core/engine-precondition.js';
 import { getStagedDiffForFiles } from '../core/git-diff.js';
 import { stageFiles, unstageFiles } from '../core/git-file-ops.js';
 import { extractAffectedFiles } from '../core/patch-apply.js';
@@ -30,14 +30,7 @@ export async function resolveCommand(projectRoot, options = {}) {
     }
     const { patchFilename } = state.pendingResolution;
     info(`Resolving conflict for patch: ${patchFilename}`);
-    // Check if engine exists
-    if (!(await pathExists(paths.engine))) {
-        throw new GeneralError('Firefox source not found. Run "fireforge download" first.');
-    }
-    // Check if it's a git repository
-    if (!(await isGitRepository(paths.engine))) {
-        throw new GeneralError('Engine directory is not a git repository. Run "fireforge download" to initialize.');
-    }
+    await assertEngineGitReady(paths.engine);
     // Non-interactive mode requires an explicit `--yes` to proceed: the
     // operator is asserting the manual merge is complete and the
     // refreshed diff is the one to record. Without `--yes`, an accidental

package/dist/src/commands/run.js

@@ -5,16 +5,17 @@ import { join } from 'node:path';
 import { Command } from 'commander';
 import { getProjectPaths, loadConfig } from '../core/config.js';
 import { warnIfFurnaceStale } from '../core/furnace-staleness.js';
-import { buildArtifactMismatchMessage, hasBuildArtifacts, hasRunnableBundle, run, runMachSmoke, } from '../core/mach.js';
-import { compileAllowlistFromFile, compileAllowlistFromStrings, matchesAllowlist, matchesSmokeError, } from '../core/smoke-patterns.js';
+import { hasBuildArtifacts, hasRunnableBundle, run, runMachSmoke } from '../core/mach.js';
+import { assertBuildArtifacts } from '../core/mach-build-artifacts.js';
+import { compileAllowlistFromFile, compileAllowlistFromStrings, matchAllowlist, matchesSmokeError, } from '../core/smoke-patterns.js';
 import { GeneralError, InvalidArgumentError } from '../errors/base.js';
-import { AmbiguousBuildArtifactsError, BuildError } from '../errors/build.js';
+import { BuildError } from '../errors/build.js';
 import { ExitCode } from '../errors/codes.js';
 import { SmokeRunError } from '../errors/run.js';
 import { toError } from '../utils/errors.js';
 import { pathExists, removeDir, removeFile } from '../utils/fs.js';
 import { info, intro, verbose, warn } from '../utils/logger.js';
-import { commanderArgParser, pickDefined } from '../utils/options.js';
+import { commanderArgParser, pickDefined, stringListOption } from '../utils/options.js';
 /**
  * Exit code returned by smoke-run mode when the captured console stream
  * produced one or more error lines that did NOT match the operator's
@@ -81,20 +82,12 @@ export async function runCommand(projectRoot, options = {}) {
         throw new GeneralError('Firefox source not found. Run "fireforge download" first.');
     }
     const buildCheck = await hasBuildArtifacts(paths.engine);
-    if (buildCheck.ambiguous && buildCheck.objDirs && buildCheck.objDirs.length > 0) {
-        throw new AmbiguousBuildArtifactsError(buildCheck.objDirs);
-    }
-    const mismatchMessage = buildArtifactMismatchMessage(paths.engine, buildCheck, 'Run');
-    if (mismatchMessage) {
-        throw new GeneralError(mismatchMessage);
-    }
-    if (!buildCheck.exists) {
-        const detail = buildCheck.objDir
-            ? `Build artifacts incomplete in ${buildCheck.objDir}/`
-            : 'No build artifacts found (obj-*/ directory missing)';
-        throw new GeneralError(`Run requires a completed build. ${detail}\n\n` +
-            "Run 'fireforge build' first, then rerun 'fireforge run'.");
-    }
+    assertBuildArtifacts(paths.engine, buildCheck, {
+        label: 'Run',
+        requirement: 'Run requires a completed build.',
+        remediation: "Run 'fireforge build' first, then rerun 'fireforge run'.",
+        requireExisting: true,
+    });
     // `hasBuildArtifacts` only checks for an `obj-*/dist/` directory; a
     // build that configured but hasn't yet produced the launchable binary
     // (common in a long real Firefox compile that the operator stopped
@@ -186,6 +179,7 @@ async function runSmokeExit(engineDir, options) {
     const findings = [];
     let allowlistedErrorHits = 0;
     let allowlistedTotalHits = 0;
+    const allowlistHits = new Array(allowlist.length).fill(0);
     const handleLine = (stream, line) => {
         // Mirror raw output to the terminal so operators watching the smoke
         // run still see what the browser is printing. Stream selection on the
@@ -201,9 +195,11 @@ async function runSmokeExit(engineDir, options) {
         // total set of allowlisted lines (what the operator sees in the
         // console) and the subset that were error-class (what the smoke
         // exit contract cares about). The exit contract itself is unchanged.
-        const isAllowlisted = allowlist.length > 0 && matchesAllowlist(line, allowlist);
+        const matchIndex = allowlist.length > 0 ? matchAllowlist(line, allowlist) : -1;
+        const isAllowlisted = matchIndex !== -1;
         if (isAllowlisted) {
             allowlistedTotalHits += 1;
+            allowlistHits[matchIndex] = (allowlistHits[matchIndex] ?? 0) + 1;
         }
         if (!matchesSmokeError(line))
             return;
@@ -249,6 +245,8 @@ async function runSmokeExit(engineDir, options) {
         timedOut: result.timedOut,
         allowlistedErrorHits,
         allowlistedTotalHits,
+        allowlist,
+        allowlistHits,
         findings,
         exitCode: result.exitCode,
     });
@@ -314,6 +312,17 @@ function reportSmokeSummary(args) {
     info(`  Allowlisted error hits (suppressed): ${String(args.allowlistedErrorHits)}`);
     info(`  Allowlisted lines total: ${String(args.allowlistedTotalHits)}`);
     info(`  Child exit code:  ${String(args.exitCode)}`);
+    // Per-entry attribution (FORGE G8): first-match credit per line, with
+    // zero-hit entries always visible — an allowlist entry whose suppressed
+    // shape changed upstream is only detectable as a 0× row.
+    if (args.allowlist.length > 0) {
+        info('  Allowlist attribution (first matching entry per line):');
+        args.allowlist.forEach((entry, index) => {
+            const hits = args.allowlistHits[index] ?? 0;
+            const zeroSuffix = hits === 0 ? '  (never matched — candidate for removal)' : '';
+            info(`    ${String(hits)}×  ${entry.origin}  ${entry.source}${zeroSuffix}`);
+        });
+    }
     if (args.findings.length === 0)
         return;
     warn('');
@@ -338,10 +347,7 @@ export function registerRun(program, { getProjectRoot, withErrorHandling }) {
         }
         return parsed;
     }))
-        .option('--console-allow <regex>', 'Allowlist regex (repeatable). Lines that match any entry do not count toward the smoke exit code.', (value, acc) => {
-        acc.push(value);
-        return acc;
-    }, [])
+        .option('--console-allow <regex>', 'Allowlist regex (repeatable). Lines that match any entry do not count toward the smoke exit code.', ...stringListOption())
         .option('--console-allow-file <path>', 'Newline-delimited allowlist regex file. Blank lines and # comments are ignored.')
         .option('--capture-console <file>', 'Mirror captured console output to <file> for post-exit inspection.')
         .option('--headless', 'Launch the browser with --headless. Recommended for --smoke-exit on a shared desktop: input into a headed smoke window contaminates the console capture.')

package/dist/src/commands/source.js

@@ -4,13 +4,7 @@ import { configExists, loadRawConfigDocument, validateConfig, withConfigFileLock
 import { resolveArchive } from '../core/firefox-archive.js';
 import { GeneralError, InvalidArgumentError } from '../errors/base.js';
 import { info, intro, outro, success } from '../utils/logger.js';
-import { isValidFirefoxCandidate, isValidFirefoxProduct } from '../utils/validation.js';
-const SOURCE_PRODUCTS = [
-    'firefox',
-    'firefox-esr',
-    'firefox-beta',
-    'firefox-devedition',
-];
+import { FIREFOX_PRODUCTS, isValidFirefoxCandidate, isValidFirefoxProduct, } from '../utils/validation.js';
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -25,7 +19,7 @@ function parseSourceProduct(product) {
     if (isValidFirefoxProduct(product)) {
         return product;
     }
-    throw new InvalidArgumentError(`--product must be one of: ${SOURCE_PRODUCTS.join(', ')}`, '--product');
+    throw new InvalidArgumentError(`--product must be one of: ${FIREFOX_PRODUCTS.join(', ')}`, '--product');
 }
 function parseSourceCandidate(candidate) {
     if (isValidFirefoxCandidate(candidate)) {
@@ -99,7 +93,7 @@ export function registerSource(program, { getProjectRoot, withErrorHandling }) {
         .description('Atomically set Firefox source version, product, and optional checksum')
         .requiredOption('--version <version>', 'Firefox version to base on')
         .addOption(new Option('--product <product>', 'Firefox product')
-        .choices([...SOURCE_PRODUCTS])
+        .choices([...FIREFOX_PRODUCTS])
         .makeOptionMandatory())
         .option('--sha256 <hash>', 'Pinned SHA-256 for the resolved source archive')
         .option('--clear-sha256', 'Clear any existing pinned SHA-256')

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

@@ -0,0 +1,48 @@
+/**
+ * `status --check` enforcement policy (FORGE G1). Turns the classified
+ * status view into a CI-enforceable non-zero exit: the default policy
+ * fails on any classification outside {patch-backed, branding, furnace},
+ * and `--fail-on <class,...>` replaces that set for finer control.
+ *
+ * Helper module consumed by status.ts (which sits at the max-lines
+ * budget); no top-level registrar is exported and none is wanted.
+ */
+import type { ClassifiedFile, FileClassification } from '../core/status-classify.js';
+/** Resolved `--check`/`--fail-on` policy for one status invocation. */
+export interface StatusCheckPolicy {
+    checkEnabled: boolean;
+    failOn: readonly FileClassification[];
+}
+/**
+ * Resolves the enforcement policy from the raw flags: `--fail-on` implies
+ * `--check` and replaces the default set; both are refused alongside the
+ * modes that skip (or elide) classification.
+ */
+export declare function resolveStatusCheckPolicy(options: {
+    check?: boolean;
+    failOn?: string;
+    raw?: boolean;
+    unmanaged?: boolean;
+    ownership?: boolean;
+    testCoverage?: boolean;
+}): StatusCheckPolicy;
+/** One fail-set classification with a non-empty file list. */
+export interface StatusCheckOffender {
+    classification: FileClassification;
+    count: number;
+    files: string[];
+}
+/**
+ * Collects the fail-set classifications that have offending files, in
+ * policy order with full file lists. Shared by the human `--check`
+ * verdict and the `--json --summary` payload so the two views can never
+ * disagree about what failed.
+ */
+export declare function collectStatusCheckOffenders(classified: readonly ClassifiedFile[], policy: StatusCheckPolicy): StatusCheckOffender[];
+/**
+ * Throws a GeneralError (exit 1) when the policy is enabled and any of
+ * its classifications is non-empty, naming each offending classification
+ * with its first few files. A disabled policy or a fully tool-covered
+ * tree passes silently.
+ */
+export declare function runStatusCheck(classified: readonly ClassifiedFile[], policy: StatusCheckPolicy): void;

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

@@ -0,0 +1,106 @@
+import { GeneralError, InvalidArgumentError } from '../errors/base.js';
+const ALL_CLASSIFICATIONS = [
+    'patch-backed',
+    'patch-owned-drift',
+    'unmanaged',
+    'branding',
+    'furnace',
+    'conflict',
+    'binary-unsupported',
+];
+/**
+ * Default `--check` policy: everything outside {patch-backed, branding,
+ * furnace, binary-unsupported} fails. `binary-unsupported` is deliberately
+ * excluded — an honest "cannot compare" must not keep the gate permanently
+ * red (FORGE J3); strict CI can opt in via `--fail-on binary-unsupported`.
+ */
+const DEFAULT_FAIL_CLASSIFICATIONS = [
+    'unmanaged',
+    'patch-owned-drift',
+    'conflict',
+];
+/**
+ * Resolves the enforcement policy from the raw flags: `--fail-on` implies
+ * `--check` and replaces the default set; both are refused alongside the
+ * modes that skip (or elide) classification.
+ */
+export function resolveStatusCheckPolicy(options) {
+    const failOnList = parseFailOnClassifications(options.failOn);
+    const checkEnabled = options.check === true || failOnList !== undefined;
+    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');
+    }
+    return { checkEnabled, failOn: failOnList ?? DEFAULT_FAIL_CLASSIFICATIONS };
+}
+function isClassification(value) {
+    return ALL_CLASSIFICATIONS.includes(value);
+}
+/**
+ * Parses a comma-separated `--fail-on` value into a classification list.
+ * Returns undefined when the flag was not given (the caller then applies
+ * the default policy only under `--check`).
+ */
+function parseFailOnClassifications(raw) {
+    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(`--fail-on requires at least one classification. Valid: ${ALL_CLASSIFICATIONS.join(', ')}.`, '--fail-on');
+    }
+    const classifications = [];
+    for (const part of parts) {
+        if (!isClassification(part)) {
+            throw new InvalidArgumentError(`Unknown --fail-on classification "${part}". Valid: ${ALL_CLASSIFICATIONS.join(', ')}.`, '--fail-on');
+        }
+        if (!classifications.includes(part))
+            classifications.push(part);
+    }
+    return classifications;
+}
+const CHECK_FILE_PREVIEW_MAX = 3;
+/**
+ * Collects the fail-set classifications that have offending files, in
+ * policy order with full file lists. Shared by the human `--check`
+ * verdict and the `--json --summary` payload so the two views can never
+ * disagree about what failed.
+ */
+export function collectStatusCheckOffenders(classified, policy) {
+    const offenders = [];
+    for (const classification of policy.failOn) {
+        const files = classified
+            .filter((entry) => entry.classification === classification)
+            .map((entry) => entry.file);
+        if (files.length === 0)
+            continue;
+        offenders.push({ classification, count: files.length, files });
+    }
+    return offenders;
+}
+/**
+ * Throws a GeneralError (exit 1) when the policy is enabled and any of
+ * its classifications is non-empty, naming each offending classification
+ * with its first few files. A disabled policy or a fully tool-covered
+ * tree passes silently.
+ */
+export function runStatusCheck(classified, policy) {
+    if (!policy.checkEnabled)
+        return;
+    const offending = collectStatusCheckOffenders(classified, policy).map((offender) => {
+        const preview = offender.files.slice(0, CHECK_FILE_PREVIEW_MAX).join(', ');
+        const more = offender.count > CHECK_FILE_PREVIEW_MAX
+            ? `, +${String(offender.count - CHECK_FILE_PREVIEW_MAX)} more`
+            : '';
+        return `${String(offender.count)} ${offender.classification} (${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

@@ -0,0 +1,31 @@
+/**
+ * `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`, FORGE K8),
+ *   which omits `files[]` entirely — engine-clean gates need the verdict,
+ *   per-class counts, and offender names, not a payload that grows with
+ *   the queue (175 KB+ observed on a 290-patch consumer).
+ */
+import type { ClassifiedFile } from '../core/status-classify.js';
+import { type StatusCheckPolicy } from './status-check.js';
+import type { OwnershipJsonBlock } from './status-ownership.js';
+/**
+ * Full `--json` payload: summary plus the per-file `files[]` list, and —
+ * under `--include-ownership` (FORGE L3) — the additive `ownership` block.
+ * Additive within schemaVersion 1: a consumer that does not ask for the
+ * block never sees the key.
+ */
+export declare function renderJsonStatus(classified: readonly ClassifiedFile[], ownership?: OwnershipJsonBlock): void;
+/**
+ * Summary-only `--json --summary` payload: counts always; when the
+ * `--check`/`--fail-on` policy is active, a `check` block with the active
+ * fail set, the verdict, and the offending files per fail-set
+ * classification (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[], policy: StatusCheckPolicy, ownership?: OwnershipJsonBlock): void;

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

@@ -0,0 +1,76 @@
+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;
+}
+/**
+ * Full `--json` payload: summary plus the per-file `files[]` list, and —
+ * under `--include-ownership` (FORGE L3) — the additive `ownership` block.
+ * Additive within schemaVersion 1: a consumer that does not ask for the
+ * block never sees the key.
+ */
+export function renderJsonStatus(classified, ownership) {
+    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;
+    });
+    const output = {
+        schemaVersion: 1,
+        summary: {
+            total: outputFiles.length,
+            byClassification: countByClassification(classified),
+        },
+        files: outputFiles,
+        ...(ownership !== undefined ? { ownership } : {}),
+    };
+    process.stdout.write(JSON.stringify(output, null, 2) + '\n');
+}
+/**
+ * Summary-only `--json --summary` payload: counts always; when the
+ * `--check`/`--fail-on` policy is active, a `check` block with the active
+ * fail set, the verdict, and the offending files per fail-set
+ * classification (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, policy, ownership) {
+    const output = {
+        schemaVersion: 1,
+        summary: {
+            total: classified.length,
+            byClassification: countByClassification(classified),
+        },
+    };
+    if (policy.checkEnabled) {
+        const offenders = collectStatusCheckOffenders(classified, policy);
+        output.check = {
+            enabled: true,
+            failOn: policy.failOn,
+            failed: offenders.length > 0,
+            offenders,
+        };
+    }
+    if (ownership !== undefined) {
+        output.ownership = ownership;
+    }
+    process.stdout.write(JSON.stringify(output, null, 2) + '\n');
+}

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

@@ -7,6 +7,7 @@ export interface ClassifiedBuckets {
     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>;

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

@@ -107,7 +107,7 @@ function renderConflictSection(conflict) {
 }
 /** Renders the default classified status buckets. */
 export async function renderDefaultStatus(totalModified, buckets, projectRoot, binaryName) {
-    const { conflict, unmanaged, patchBacked, patchOwnedDrift, branding, furnace } = buckets;
+    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
@@ -163,6 +163,15 @@ export async function renderDefaultStatus(totalModified, buckets, projectRoot, b
                 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) {

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

@@ -0,0 +1,52 @@
+/**
+ * Ownership-table assembly for `status`, split out of `status.ts` (FORGE
+ * L3) so the human `--ownership` mode and the additive `ownership` block on
+ * the `--json` payload build the SAME rows from the SAME scan.
+ *
+ * Before L3 the `--ownership` branch re-implemented the shared scan and
+ * inlined a second copy of the classification call, then discarded
+ * everything but each file's classification — three back-to-back `status`
+ * invocations in a gate therefore paid three full worktree scans. Both
+ * callers now hand this module the already-classified files.
+ *
+ * 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 the alignment fix between `status --ownership` and
+ * `fireforge verify` (see `buildOwnershipTable`'s header).
+ * @param patchesDir - Path to the patches directory
+ * @param manifestPatches - Patch rows from patches.json (empty when absent)
+ * @param files - Scanned worktree entries, temp-filtered
+ * @param classified - The same entries, already classified
+ */
+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

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Ownership-table assembly for `status`, split out of `status.ts` (FORGE
+ * L3) so the human `--ownership` mode and the additive `ownership` block on
+ * the `--json` payload build the SAME rows from the SAME scan.
+ *
+ * Before L3 the `--ownership` branch re-implemented the shared scan and
+ * inlined a second copy of the classification call, then discarded
+ * everything but each file's classification — three back-to-back `status`
+ * invocations in a gate therefore paid three full worktree scans. Both
+ * callers now hand this module the already-classified files.
+ *
+ * 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 the alignment fix between `status --ownership` and
+ * `fireforge verify` (see `buildOwnershipTable`'s header).
+ * @param patchesDir - Path to the patches directory
+ * @param manifestPatches - Patch rows from patches.json (empty when absent)
+ * @param files - Scanned worktree entries, temp-filtered
+ * @param classified - The same entries, already classified
+ */
+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) };
+}