@hominis/fireforge 0.55.0 → 0.60.0

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

@@ -1,98 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * `fireforge check` output: the per-step table, the single
- * `FIREFORGE-VERDICT:` line, and the `--json` document. The verdict is
- * computed once here and shared by all three, so the exit code, the line
- * and the JSON can never disagree.
- */
-import { setStdoutSealed } from '../utils/logger.js';
-/** Exit code a step reports when its lock wait expired. */
-const LOCK_TIMEOUT_EXIT = 15;
-/**
- * Judges the results: any failing step fails the check. Under
- * `failOnSkipped`, so does a step skipped because the project has nothing
- * for it to run; it is then listed in `failed` too.
- */
-export function judgeCheck(results, options = {}) {
-    const failedResults = results.filter((result) => result.status === 'fail');
-    const gaps = options.failOnSkipped === true
-        ? results.filter((result) => result.status === 'skipped' && result.skipKind !== 'config')
-        : [];
-    const verdict = {
-        passed: failedResults.length === 0 && gaps.length === 0,
-        failed: [...failedResults, ...gaps].map((result) => result.name),
-        skipped: results.filter((result) => result.status === 'skipped').map((result) => result.name),
-        steps: results.length,
-    };
-    if (failedResults.length > 0) {
-        verdict.reason = failedResults.every((result) => result.exitCode === LOCK_TIMEOUT_EXIT)
-            ? 'lock-timeout'
-            : 'step-failures';
-    }
-    else if (gaps.length > 0) {
-        verdict.reason = 'skipped-steps';
-    }
-    return verdict;
-}
-/**
- * The verdict line: `FIREFORGE-VERDICT: PASS steps=<n> skipped=<n>` or
- * `FIREFORGE-VERDICT: FAIL reason=<reason> failed=<a,b> steps=<n> skipped=<n>`,
- * with an additive `skipped-steps=<a,b>` naming the skipped steps when
- * there are any.
- */
-export function formatCheckVerdictLine(verdict) {
-    const skippedNames = verdict.skipped.length > 0 ? ` skipped-steps=${verdict.skipped.join(',')}` : '';
-    const counts = `steps=${verdict.steps} skipped=${verdict.skipped.length}${skippedNames}`;
-    if (verdict.passed)
-        return `FIREFORGE-VERDICT: PASS ${counts}`;
-    return `FIREFORGE-VERDICT: FAIL reason=${verdict.reason ?? 'step-failures'} failed=${verdict.failed.join(',')} ${counts}`;
-}
-function formatDuration(ms) {
-    return ms < 1000 ? `${ms}ms` : `${(ms / 1000).toFixed(1)}s`;
-}
-/** The step's 1-minute load average at start and end (`12.3→18.0`), or `-`. */
-function formatLoad(result) {
-    if (result.load1Start === undefined || result.load1End === undefined)
-        return '-';
-    return `${result.load1Start.toFixed(1)}→${result.load1End.toFixed(1)}`;
-}
-/** The per-step table: one aligned row per step, with its detail. */
-export function formatCheckTable(results) {
-    const rows = results.map((result) => [
-        result.name,
-        result.status.toUpperCase(),
-        result.status === 'skipped' ? '-' : formatDuration(result.durationMs),
-        formatLoad(result),
-        result.detail,
-    ]);
-    const header = ['STEP', 'RESULT', 'TIME', 'LOAD', 'DETAIL'];
-    const widths = header.map((title, column) => Math.max(title.length, ...rows.map((row) => row[column]?.length ?? 0)));
-    return [header, ...rows]
-        .map((row) => row
-        .map((cell, column) => column === row.length - 1 ? cell : cell.padEnd(widths[column] ?? 0))
-        .join('  ')
-        .trimEnd())
-        .join('\n');
-}
-/** Writes the verdict line as the run's last stdout write, and seals stdout. */
-export function writeCheckVerdictLine(verdict) {
-    process.stdout.write(`${formatCheckVerdictLine(verdict)}\n`);
-    setStdoutSealed(true);
-}
-/** Writes the `--json` document (schemaVersion 1) and seals stdout. */
-export function writeCheckJson(results, verdict) {
-    const payload = {
-        schemaVersion: 1,
-        verdict: verdict.passed ? 'pass' : 'fail',
-        ...(verdict.reason !== undefined ? { reason: verdict.reason } : {}),
-        summary: {
-            steps: verdict.steps,
-            passed: results.filter((result) => result.status === 'pass').length,
-            failed: verdict.failed.length,
-            skipped: verdict.skipped.length,
-        },
-        steps: results,
-    };
-    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
-    setStdoutSealed(true);
-}

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

@@ -1,44 +0,0 @@
-import type { CheckStepPlan } from './check-steps.js';
-/** What a step's table row and JSON entry report. */
-export interface CheckStepResult {
-    name: string;
-    kind: 'builtin' | 'extra';
-    /** The command line, as the table prints it. */
-    command: string;
-    status: 'pass' | 'fail' | 'skipped';
-    /**
-     * For a skipped step: `config` when `check.skip` names it, `unavailable`
-     * when the project has nothing for it to run.
-     */
-    skipKind?: 'config' | 'unavailable';
-    /** The child's exit code. Null when it never ran or was killed at its budget. */
-    exitCode: number | null;
-    durationMs: number;
-    /** One-line summary for the table. */
-    detail: string;
-    /** Set when the step was killed at its `timeout`. */
-    timedOut?: true;
-    /** The tail of the step's combined output, for a failed step. */
-    outputTail?: string;
-    /**
-     * The host's 1-minute load average when the step started and when it
-     * ended. Absent for a skipped step and on Windows, which has no load
-     * average.
-     */
-    load1Start?: number;
-    load1End?: number;
-}
-/** Samples the host's 1-minute load average; undefined where there is none. */
-type LoadSampler = () => number | undefined;
-/**
- * Runs every step and returns the results in plan order. A step starts
- * once a slot is free and every step it runs `after` has finished
- * (whatever its outcome: the constraint is ordering, not success).
- *
- * @param plans - The plan from `buildCheckPlan`, already filtered
- * @param jobs - How many steps may run at once (at least 1)
- * @param now - Clock, injectable for tests
- * @param load - 1-minute load average sampler, injectable for tests
- */
-export declare function runCheckSteps(plans: readonly CheckStepPlan[], jobs: number, now?: () => number, load?: LoadSampler): Promise<CheckStepResult[]>;
-export {};

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

@@ -1,125 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Runs the `fireforge check` plan: up to `jobs` steps at once, each as a
- * child process in its own process group (so a timeout or a Ctrl+C takes
- * the step's whole tree), honouring each step's `after` ordering.
- */
-import { loadavg } from 'node:os';
-import { ExecTimeoutError } from '../errors/base.js';
-import { toError } from '../utils/errors.js';
-import { execStream } from '../utils/process.js';
-/** `os.loadavg()[0]`, or undefined on Windows, where Node reports zeros. */
-function sampleLoad1() {
-    return process.platform === 'win32' ? undefined : loadavg()[0];
-}
-/** Both load samples, or nothing when either is unavailable. */
-function loadFields(start, end) {
-    return start === undefined || end === undefined ? {} : { load1Start: start, load1End: end };
-}
-/** Combined output kept per step: enough for a tail, bounded for a chatty audit. */
-const COMBINED_OUTPUT_CAP = 256 * 1024;
-/** Lines of output a failed step carries in its result. */
-const OUTPUT_TAIL_LINES = 40;
-function tailLines(text) {
-    const lines = text.trimEnd().split(/\r?\n/);
-    return lines.slice(-OUTPUT_TAIL_LINES).join('\n');
-}
-/** Runs one planned step to completion. Never throws. */
-async function runStep(plan, now, load) {
-    const base = { name: plan.name, kind: plan.kind, command: plan.display };
-    if (plan.skipReason !== undefined) {
-        return {
-            ...base,
-            status: 'skipped',
-            skipKind: plan.skipKind ?? 'unavailable',
-            exitCode: null,
-            durationMs: 0,
-            detail: plan.skipReason,
-        };
-    }
-    let stdout = '';
-    let combined = '';
-    const append = (chunk) => {
-        combined += chunk;
-        if (combined.length > COMBINED_OUTPUT_CAP)
-            combined = combined.slice(-COMBINED_OUTPUT_CAP);
-    };
-    const started = now();
-    const load1Start = load();
-    try {
-        const exitCode = await execStream(plan.command, plan.args, {
-            cwd: plan.cwd,
-            processGroup: true,
-            ...(plan.timeoutMs !== undefined ? { timeout: plan.timeoutMs } : {}),
-            ...(plan.env !== undefined ? { env: plan.env } : {}),
-            onStdout: (chunk) => {
-                stdout += chunk;
-                append(chunk);
-            },
-            onStderr: append,
-        });
-        const status = exitCode === 0 ? 'pass' : 'fail';
-        return {
-            ...base,
-            status,
-            exitCode,
-            durationMs: now() - started,
-            ...loadFields(load1Start, load()),
-            detail: plan.summarize({ stdout, combined, exitCode }),
-            ...(status === 'fail' ? { outputTail: tailLines(combined) } : {}),
-        };
-    }
-    catch (error) {
-        const timedOut = error instanceof ExecTimeoutError;
-        return {
-            ...base,
-            status: 'fail',
-            exitCode: null,
-            durationMs: now() - started,
-            ...loadFields(load1Start, load()),
-            detail: timedOut
-                ? `timed out after ${Math.round((plan.timeoutMs ?? 0) / 1000)}s`
-                : `could not start: ${toError(error).message}`,
-            ...(timedOut ? { timedOut: true } : {}),
-            outputTail: tailLines(combined),
-        };
-    }
-}
-/**
- * Runs every step and returns the results in plan order. A step starts
- * once a slot is free and every step it runs `after` has finished
- * (whatever its outcome: the constraint is ordering, not success).
- *
- * @param plans - The plan from `buildCheckPlan`, already filtered
- * @param jobs - How many steps may run at once (at least 1)
- * @param now - Clock, injectable for tests
- * @param load - 1-minute load average sampler, injectable for tests
- */
-export async function runCheckSteps(plans, jobs, now = Date.now, load = sampleLoad1) {
-    const names = new Set(plans.map((plan) => plan.name));
-    const results = new Map();
-    const pending = [...plans];
-    const running = new Map();
-    const isReady = (plan) => plan.after.every((dependency) => !names.has(dependency) || results.has(dependency));
-    while (pending.length > 0 || running.size > 0) {
-        for (let index = 0; index < pending.length && running.size < Math.max(1, jobs);) {
-            const plan = pending[index];
-            if (plan === undefined || !isReady(plan)) {
-                index++;
-                continue;
-            }
-            pending.splice(index, 1);
-            running.set(plan.name, runStep(plan, now, load).then((result) => {
-                results.set(plan.name, result);
-                running.delete(plan.name);
-            }));
-        }
-        if (running.size === 0)
-            break;
-        await Promise.race(running.values());
-    }
-    return plans.flatMap((plan) => {
-        const result = results.get(plan.name);
-        return result === undefined ? [] : [result];
-    });
-}

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

@@ -1,75 +0,0 @@
-import type { CheckConfig, FireForgeConfig } from '../types/config.js';
-/** One planned step. */
-export interface CheckStepPlan {
-    name: string;
-    kind: 'builtin' | 'extra';
-    /** Executable to spawn. */
-    command: string;
-    /** Its arguments. */
-    args: string[];
-    /** The command line as the table prints it. */
-    display: string;
-    cwd: string;
-    timeoutMs?: number | undefined;
-    /** Steps that must finish before this one starts (ordering only). */
-    after: string[];
-    /** Set when the step is planned but not run, with the reason. */
-    skipReason?: string | undefined;
-    /**
-     * Why it is skipped: `config` when `check.skip` names it (a decision),
-     * `unavailable` when the project has nothing for it to run (a gap,
-     * which `check.failOnSkipped` fails).
-     */
-    skipKind?: 'config' | 'unavailable' | undefined;
-    /** Extra environment for the child. */
-    env?: Record<string, string> | undefined;
-    /** Condenses a finished run into the table's detail cell. */
-    summarize: (output: {
-        stdout: string;
-        combined: string;
-        exitCode: number;
-    }) => string;
-}
-/** The project facts the plan depends on. */
-export interface CheckPlanInput {
-    projectRoot: string;
-    config: FireForgeConfig;
-    furnaceConfigured: boolean;
-    /** Resolved `--patches` filenames, forwarded to status, verify and lint. */
-    patches?: string[] | undefined;
-}
-/**
- * The generic detail: nothing on success, and on failure the last line
- * the step printed (its refusal, usually), cut to fit a table cell.
- */
-export declare function lastOutputLine(combined: string, exitCode: number): string;
-/** Status detail from its `--json --summary` document: the failing classes. */
-export declare function summarizeStatus(output: {
-    stdout: string;
-    combined: string;
-    exitCode: number;
-}): string;
-/** Furnace detail from its `--json` document: counts after exceptions. */
-export declare function summarizeFurnace(output: {
-    stdout: string;
-    combined: string;
-    exitCode: number;
-}): string;
-/** Token-coverage detail: the coverage percentage it reports. */
-export declare function summarizeTokenCoverage(output: {
-    stdout: string;
-    combined: string;
-    exitCode: number;
-}): string;
-/** The status step's `--check` flags from `check.status`. */
-export declare function statusPolicyArgs(policy: CheckConfig['status']): string[];
-/**
- * Builds the full plan: the six built-in steps (with the ones this project
- * cannot run marked skipped) followed by `check.extraSteps[]`.
- *
- * `furnace-validate` waits for `typecheck`, the one built-in step that
- * writes: it regenerates a stale Furnace jsconfig, whose drift
- * `furnace validate` reports. Run side by side, the two would race on that
- * file and the verdict would depend on which won.
- */
-export declare function buildCheckPlan(input: CheckPlanInput): CheckStepPlan[];

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

@@ -1,200 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * The step plan of `fireforge check`: which commands run, with which
- * arguments, in which order constraints, and how each one's output is
- * condensed into its table row.
- *
- * Every built-in step is the real command run as a child `fireforge`
- * process, not an in-process call. That is what keeps the gate's output
- * sane (each command owns its stdout, its machine mode and its error
- * boundary) and what avoids double locking: `check` itself takes no lock,
- * so each child takes exactly the locks its command takes standalone.
- * None of the built-in steps takes the engine session lock, which is why
- * they can run side by side.
- */
-import { join } from 'node:path';
-import { GeneralError } from '../errors/base.js';
-/**
- * How to re-run this CLI as a child: the same Node, the same loader flags
- * (minus debugger flags, whose port the parent already holds), the same
- * entry script.
- */
-function fireforgeInvocation() {
-    const entry = process.argv[1];
-    if (entry === undefined) {
-        throw new GeneralError('Cannot resolve the fireforge CLI entry point for check steps.');
-    }
-    const loaderFlags = process.execArgv.filter((flag) => !flag.startsWith('--inspect'));
-    return { command: process.execPath, prefix: [...loaderFlags, entry] };
-}
-/** Strips clack's gutter glyphs so a captured line reads as plain text. */
-function plainLine(line) {
-    return line.replace(/^[\s│■●◆◇▲└┌|]+/u, '').trim();
-}
-/**
- * The generic detail: nothing on success, and on failure the last line
- * the step printed (its refusal, usually), cut to fit a table cell.
- */
-export function lastOutputLine(combined, exitCode) {
-    if (exitCode === 0)
-        return '';
-    const lines = combined
-        .split(/\r?\n/)
-        .map(plainLine)
-        .filter((line) => line.length > 0);
-    const last = lines.at(-1) ?? '';
-    return last.length > 120 ? `${last.slice(0, 117)}...` : last;
-}
-function parseJsonDocument(stdout) {
-    try {
-        const parsed = JSON.parse(stdout);
-        return typeof parsed === 'object' && parsed !== null
-            ? parsed
-            : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-/** Status detail from its `--json --summary` document: the failing classes. */
-export function summarizeStatus(output) {
-    const doc = parseJsonDocument(output.stdout);
-    if (doc?.summary === undefined)
-        return lastOutputLine(output.combined, output.exitCode);
-    const offenders = doc.check?.offenders ?? [];
-    if (offenders.length > 0) {
-        return offenders.map((entry) => `${entry.count} ${entry.classification}`).join(', ');
-    }
-    return `${doc.summary.total ?? 0} changed file(s), none failing`;
-}
-/** Furnace detail from its `--json` document: counts after exceptions. */
-export function summarizeFurnace(output) {
-    const doc = parseJsonDocument(output.stdout);
-    if (doc?.summary === undefined)
-        return lastOutputLine(output.combined, output.exitCode);
-    const { errors, warnings, excepted, staleExceptions } = doc.summary;
-    const extra = [
-        excepted > 0 ? `${excepted} excepted` : '',
-        staleExceptions > 0 ? `${staleExceptions} stale exception(s)` : '',
-    ].filter((part) => part.length > 0);
-    return [`${errors} error(s), ${warnings} warning(s)`, ...extra].join(', ');
-}
-/** Token-coverage detail: the coverage percentage it reports. */
-export function summarizeTokenCoverage(output) {
-    const match = /Token coverage: (\d+)%/.exec(output.combined);
-    if (match?.[1] !== undefined)
-        return `coverage ${match[1]}%`;
-    if (output.combined.includes('No modified CSS files'))
-        return 'no modified CSS';
-    return lastOutputLine(output.combined, output.exitCode);
-}
-function generic(output) {
-    return lastOutputLine(output.combined, output.exitCode);
-}
-/** The status step's `--check` flags from `check.status`. */
-export function statusPolicyArgs(policy) {
-    const args = [];
-    if (policy?.failOn !== undefined)
-        args.push('--fail-on', policy.failOn.join(','));
-    if (policy?.allow !== undefined)
-        args.push('--allow', policy.allow.join(','));
-    if (policy?.failOnUnknown === true)
-        args.push('--fail-on-unknown');
-    return args;
-}
-function builtinStep(invocation, projectRoot, name, args, summarize, extra = {}) {
-    return {
-        name,
-        kind: 'builtin',
-        command: invocation.command,
-        args: [...invocation.prefix, ...args],
-        display: `fireforge ${args.join(' ')}`,
-        cwd: projectRoot,
-        timeoutMs: extra.timeoutMs,
-        after: extra.after ?? [],
-        skipReason: extra.skipReason,
-        skipKind: extra.skipReason !== undefined ? 'unavailable' : undefined,
-        summarize,
-    };
-}
-/** A built-in step's budget: `check.timeouts.<step>`, else `check.timeout`. */
-function builtinTimeoutMs(check, name) {
-    const seconds = check.timeouts?.[name] ?? check.timeout;
-    return seconds !== undefined ? seconds * 1000 : undefined;
-}
-/** Runs a project command line through the platform shell. */
-function shellInvocation(commandLine) {
-    return process.platform === 'win32'
-        ? { command: 'cmd.exe', args: ['/d', '/s', '/c', commandLine] }
-        : { command: '/bin/sh', args: ['-c', commandLine] };
-}
-/**
- * Builds the full plan: the six built-in steps (with the ones this project
- * cannot run marked skipped) followed by `check.extraSteps[]`.
- *
- * `furnace-validate` waits for `typecheck`, the one built-in step that
- * writes: it regenerates a stale Furnace jsconfig, whose drift
- * `furnace validate` reports. Run side by side, the two would race on that
- * file and the verdict would depend on which won.
- */
-export function buildCheckPlan(input) {
-    const { projectRoot, config } = input;
-    const invocation = fireforgeInvocation();
-    const check = config.check ?? {};
-    const patchArgs = input.patches !== undefined ? ['--patches', input.patches.join(',')] : [];
-    const lintWarnings = check.maxWarnings?.lint !== undefined ? ['--max-warnings', String(check.maxWarnings.lint)] : [];
-    const furnaceWarnings = check.maxWarnings?.furnace !== undefined
-        ? ['--max-warnings', String(check.maxWarnings.furnace)]
-        : [];
-    const lintReport = check.lintReport !== undefined ? join(projectRoot, check.lintReport) : undefined;
-    const lintReportArgs = lintReport !== undefined ? ['--report', lintReport] : [];
-    const timeoutMs = (name) => builtinTimeoutMs(check, name);
-    const plan = [
-        builtinStep(invocation, projectRoot, 'status', ['status', '--json', '--summary', '--check', ...statusPolicyArgs(check.status), ...patchArgs], summarizeStatus, { timeoutMs: timeoutMs('status') }),
-        builtinStep(invocation, projectRoot, 'verify', ['verify', ...patchArgs], generic, {
-            timeoutMs: timeoutMs('verify'),
-        }),
-        builtinStep(invocation, projectRoot, 'lint', [
-            'lint',
-            '--per-patch',
-            '--notices',
-            'summary',
-            ...lintWarnings,
-            ...lintReportArgs,
-            ...patchArgs,
-        ], generic, { timeoutMs: timeoutMs('lint') }),
-        builtinStep(invocation, projectRoot, 'typecheck', ['typecheck'], generic, {
-            skipReason: config.typecheck === undefined ? 'no "typecheck" block in fireforge.json' : undefined,
-            timeoutMs: timeoutMs('typecheck'),
-        }),
-        builtinStep(invocation, projectRoot, 'furnace-validate', ['furnace', 'validate', '--json', ...furnaceWarnings], summarizeFurnace, {
-            after: ['typecheck'],
-            skipReason: input.furnaceConfigured ? undefined : 'no furnace.json',
-            timeoutMs: timeoutMs('furnace-validate'),
-        }),
-        builtinStep(invocation, projectRoot, 'token-coverage', ['token', 'coverage'], summarizeTokenCoverage, { timeoutMs: timeoutMs('token-coverage') }),
-    ];
-    for (const step of check.extraSteps ?? []) {
-        const shell = shellInvocation(step.command);
-        plan.push({
-            name: step.name,
-            kind: 'extra',
-            command: shell.command,
-            args: shell.args,
-            display: step.command,
-            cwd: step.cwd !== undefined ? join(projectRoot, step.cwd) : projectRoot,
-            timeoutMs: step.timeout !== undefined ? step.timeout * 1000 : undefined,
-            after: step.after ?? [],
-            env: lintReport !== undefined ? { FIREFORGE_CHECK_LINT_REPORT: lintReport } : undefined,
-            summarize: generic,
-        });
-    }
-    for (const name of check.skip ?? []) {
-        const step = plan.find((entry) => entry.name === name);
-        if (step !== undefined) {
-            step.skipReason = 'skipped by check.skip in fireforge.json';
-            step.skipKind = 'config';
-        }
-    }
-    return plan;
-}

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

@@ -1,32 +0,0 @@
-import { Command } from 'commander';
-import type { CommandContext } from '../types/cli.js';
-import { type CheckStepPlan } from './check-steps.js';
-/** Options Commander forwards from `fireforge check`. */
-export interface CheckCommandOptions {
-    json?: boolean;
-    /** Judge only these patches in status, verify and lint. */
-    patches?: string[];
-    /** Comma-separated step names to leave out. */
-    skip?: string;
-    /** Comma-separated step names to run, leaving out the rest. */
-    only?: string;
-    /** Raw `--jobs` value. */
-    jobs?: string;
-}
-/**
- * Applies `--only` and `--skip` to the plan. A step left out this way is
- * dropped from the table rather than shown as skipped: the caller asked
- * for a narrower gate, not a report of what it chose not to run.
- */
-export declare function selectCheckSteps(plan: CheckStepPlan[], options: Pick<CheckCommandOptions, 'only' | 'skip'>): CheckStepPlan[];
-/** Parses `--jobs`: a positive integer. Defaults to one slot per CPU. */
-export declare function parseCheckJobs(raw: string | undefined): number;
-/**
- * Runs the composed gate.
- *
- * @param projectRoot - Project root directory
- * @param options - See {@link CheckCommandOptions}
- */
-export declare function checkCommand(projectRoot: string, options?: CheckCommandOptions): Promise<void>;
-/** Registers the `check` command on the CLI program. */
-export declare function registerCheck(program: Command, { getProjectRoot, withErrorHandling }: CommandContext): void;

package/dist/src/commands/config.d.ts

@@ -1,13 +0,0 @@
-import { Command } from 'commander';
-import type { CommandContext } from '../types/cli.js';
-/**
- * Runs the config command to get or set configuration values.
- * @param projectRoot - Root directory of the project
- * @param key - Configuration key (dot notation)
- * @param value - Optional value to set
- */
-export declare function configCommand(projectRoot: string, key: string, value?: string, options?: {
-    force?: boolean;
-}): Promise<void>;
-/** Registers the config command on the CLI program. */
-export declare function registerConfig(program: Command, { getProjectRoot, withErrorHandling }: CommandContext): void;

package/dist/src/commands/declarations-report.d.ts

@@ -1,49 +0,0 @@
-import type { ConflictReport } from '../core/destructive.js';
-import type { PatchLintIssue, PatchLintStagedDeclaration } from '../types/commands/index.js';
-/** A written declaration report and the commands that apply it. */
-export interface DeclarationsReport {
-    /** Absolute path of the JSON report. */
-    path: string;
-    /** Declarations written. */
-    count: number;
-    /** One `patch staged-dependency <holder> --add --from` call per holder. */
-    commands: string[];
-}
-/**
- * A declaration as the report records it. `owner` is optional for renamers
- * that cannot name one; `reason` is the rationale `staged-dependency --add
- * --from` records with the declaration (an entry's own reason wins over the
- * call's `--reason`).
- */
-export type ReportedDeclaration = Omit<PatchLintStagedDeclaration, 'owner'> & {
-    owner?: string;
-    reason?: string;
-};
-/** Rewrites a projected declaration into the names the current queue uses. */
-export type DeclarationRenamer = (declaration: PatchLintStagedDeclaration) => ReportedDeclaration;
-/**
- * Writes every declaration `issues` propose into one report, or returns
- * undefined when they propose none.
- *
- * @param projectRoot - Project root (the default report directory lives under it)
- * @param issues - The refusal's findings
- * @param out - `--declarations-out`, relative to the working directory
- * @param rename - Maps projected patch names back to current ones
- * @param reason - Rationale stamped on every declaration that carries none
- *   (`patch move-files` and `patch split` name the move that needs it)
- */
-export declare function writeDeclarationsReport(projectRoot: string, issues: readonly PatchLintIssue[], out?: string, rename?: DeclarationRenamer, reason?: string): Promise<DeclarationsReport | undefined>;
-/** The refusal lines that point at a written report. */
-export declare function formatDeclarationsReport(report: DeclarationsReport): string[];
-/**
- * Appends the report lines to a refusal, writing the report from the
- * refusal's findings. A refusal that proposes no declaration is returned
- * unchanged, and so is no refusal at all.
- */
-export declare function withDeclarationsReport(conflicts: ConflictReport | null, args: {
-    projectRoot: string;
-    regressions: readonly PatchLintIssue[];
-    out?: string | undefined;
-    rename?: DeclarationRenamer;
-    reason?: string;
-}): Promise<ConflictReport | null>;