@hominis/fireforge 0.9.0

package/dist/src/cli.js

@@ -0,0 +1,180 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { Command } from 'commander';
+import { registerBootstrap } from './commands/bootstrap.js';
+import { registerBuild } from './commands/build.js';
+import { registerConfig } from './commands/config.js';
+import { registerDiscard } from './commands/discard.js';
+import { registerDoctor } from './commands/doctor.js';
+import { registerDownload } from './commands/download.js';
+import { registerExport } from './commands/export.js';
+import { registerExportAll } from './commands/export-all.js';
+import { registerFurnace } from './commands/furnace/index.js';
+import { registerImport } from './commands/import.js';
+import { registerLint } from './commands/lint.js';
+import { registerPackage } from './commands/package.js';
+import { registerReExport } from './commands/re-export.js';
+import { registerRebase } from './commands/rebase.js';
+import { registerRegister } from './commands/register.js';
+import { registerReset } from './commands/reset.js';
+import { registerResolve } from './commands/resolve.js';
+import { registerRun } from './commands/run.js';
+import { registerSetup } from './commands/setup.js';
+import { registerStatus } from './commands/status.js';
+import { registerTest } from './commands/test.js';
+import { registerToken } from './commands/token.js';
+import { registerWatch } from './commands/watch.js';
+import { registerWire } from './commands/wire.js';
+import { CancellationError, CommandError, FireForgeError } from './errors/base.js';
+import { ExitCode } from './errors/codes.js';
+import { toError } from './utils/errors.js';
+import { cancel, error as logError, setVerbose } from './utils/logger.js';
+import { getPackageVersion } from './utils/package-root.js';
+const brokenPipeInstalledKey = Symbol.for('fireforge.cli.brokenPipeHandlerInstalled');
+const brokenPipeListenerKey = Symbol.for('fireforge.cli.brokenPipeHandlerListener');
+function getProcessState() {
+    return process;
+}
+function getBrokenPipeHandler(state) {
+    const existingHandler = state[brokenPipeListenerKey];
+    if (existingHandler) {
+        return existingHandler;
+    }
+    const handler = (error) => {
+        if (error.code === 'EPIPE') {
+            process.exitCode = 0;
+            return;
+        }
+        throw error;
+    };
+    state[brokenPipeListenerKey] = handler;
+    return handler;
+}
+/**
+ * Installs a handler for broken-pipe (EPIPE) errors on stdout/stderr.
+ * This is a process-level concern: when output is piped to a process that
+ * closes early (e.g. `fireforge status | head`), Node emits EPIPE.
+ * We treat this as a clean exit.
+ */
+export function installBrokenPipeHandler() {
+    const state = getProcessState();
+    if (state[brokenPipeInstalledKey]) {
+        return;
+    }
+    const handleStreamError = getBrokenPipeHandler(state);
+    process.stdout.on('error', handleStreamError);
+    process.stderr.on('error', handleStreamError);
+    state[brokenPipeInstalledKey] = true;
+}
+/** Removes the broken-pipe handler installed for CLI tests. */
+export function resetBrokenPipeHandlerForTests() {
+    const state = getProcessState();
+    const handleStreamError = state[brokenPipeListenerKey];
+    if (handleStreamError) {
+        process.stdout.off('error', handleStreamError);
+        process.stderr.off('error', handleStreamError);
+    }
+    state[brokenPipeInstalledKey] = undefined;
+    state[brokenPipeListenerKey] = undefined;
+}
+/**
+ * Gets the project root directory.
+ * Walks up from the current working directory until a fireforge.json is found.
+ * Falls back to the current working directory when no project root is found.
+ */
+export function getProjectRoot() {
+    const start = resolve(process.cwd());
+    let current = start;
+    for (;;) {
+        if (existsSync(join(current, 'fireforge.json'))) {
+            return current;
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            return start;
+        current = parent;
+    }
+}
+/**
+ * Wraps a command handler with error handling.
+ *
+ * Logs the user-visible error message and throws a {@link CommandError}
+ * carrying the appropriate exit code. The actual `process.exit()` call
+ * lives in the CLI entrypoint (`bin/fireforge.ts`), keeping shared library
+ * code free of process-terminating side effects.
+ */
+export function withErrorHandling(handler) {
+    return async (...args) => {
+        try {
+            await handler(...args);
+        }
+        catch (error) {
+            if (error instanceof CancellationError) {
+                cancel('Operation cancelled');
+                throw new CommandError(ExitCode.GENERAL_ERROR);
+            }
+            if (error instanceof FireForgeError) {
+                logError(error.userMessage);
+                throw new CommandError(error.code);
+            }
+            const normalizedError = toError(error);
+            logError(`Unexpected error: ${normalizedError.message}`);
+            if (normalizedError.stack) {
+                console.error(normalizedError.stack);
+            }
+            throw new CommandError(ExitCode.GENERAL_ERROR);
+        }
+    };
+}
+/**
+ * Creates and configures the CLI program.
+ */
+export function createProgram() {
+    const program = new Command();
+    program
+        .name('fireforge')
+        .description('A build tool for customizing Firefox')
+        .version(getPackageVersion())
+        .option('-v, --verbose', 'Enable debug output')
+        .hook('preAction', (thisCommand) => {
+        const opts = thisCommand.opts();
+        if (opts['verbose']) {
+            setVerbose(true);
+        }
+    });
+    const ctx = { getProjectRoot, withErrorHandling };
+    registerSetup(program, ctx);
+    registerDownload(program, ctx);
+    registerBootstrap(program, ctx);
+    registerImport(program, ctx);
+    registerResolve(program, ctx);
+    registerBuild(program, ctx);
+    registerRun(program, ctx);
+    registerStatus(program, ctx);
+    registerReset(program, ctx);
+    registerDiscard(program, ctx);
+    registerExport(program, ctx);
+    registerExportAll(program, ctx);
+    registerReExport(program, ctx);
+    registerRebase(program, ctx);
+    registerPackage(program, ctx);
+    registerWatch(program, ctx);
+    registerTest(program, ctx);
+    registerConfig(program, ctx);
+    registerDoctor(program, ctx);
+    registerRegister(program, ctx);
+    registerWire(program, ctx);
+    registerToken(program, ctx);
+    registerLint(program, ctx);
+    registerFurnace(program, ctx);
+    return program;
+}
+/**
+ * Main CLI entry point.
+ */
+export async function main() {
+    const program = createProgram();
+    await program.parseAsync(process.argv);
+}
+//# sourceMappingURL=cli.js.map

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

@@ -0,0 +1,9 @@
+import { Command } from 'commander';
+import type { CommandContext } from '../types/cli.js';
+/**
+ * Runs the bootstrap command.
+ * @param projectRoot - Root directory of the project
+ */
+export declare function bootstrapCommand(projectRoot: string): Promise<void>;
+/** Registers the bootstrap command on the CLI program. */
+export declare function registerBootstrap(program: Command, { getProjectRoot, withErrorHandling }: CommandContext): void;

package/dist/src/commands/bootstrap.js

@@ -0,0 +1,73 @@
+import { getProjectPaths } from '../core/config.js';
+import { ensureOriginRemote } from '../core/git.js';
+import { bootstrapWithOutput } from '../core/mach.js';
+import { GeneralError } from '../errors/base.js';
+import { BootstrapError } from '../errors/build.js';
+import { pathExists } from '../utils/fs.js';
+import { error, info, intro, outro } from '../utils/logger.js';
+function buildBootstrapFailureMessage(output) {
+    const normalized = output.replace(/\r\n/g, '\n');
+    const issues = [];
+    if (/traceback \(most recent call last\):/i.test(normalized)) {
+        issues.push('Bootstrap emitted a Python traceback.');
+    }
+    if (/\bhttp(?:\s+error)?\s*403\b/i.test(normalized) || /\b403\b.*forbidden/i.test(normalized)) {
+        issues.push('Bootstrap hit an HTTP 403 while fetching dependencies.');
+    }
+    if (/no such remote ['"]origin['"]/i.test(normalized) ||
+        /remote ['"]origin['"] does not exist/i.test(normalized) ||
+        /missing git remote ['"]origin['"]/i.test(normalized)) {
+        issues.push('Bootstrap expected an "origin" git remote in the Firefox source checkout.');
+    }
+    if (issues.length === 0) {
+        return undefined;
+    }
+    return ('Bootstrap did not complete successfully.\n\n' +
+        `${issues.join('\n')}\n\n` +
+        'Review the bootstrap output above, fix the underlying dependency or source-tree issue, and rerun "fireforge bootstrap".');
+}
+/**
+ * Runs the bootstrap command.
+ * @param projectRoot - Root directory of the project
+ */
+export async function bootstrapCommand(projectRoot) {
+    intro('FireForge Bootstrap');
+    const paths = getProjectPaths(projectRoot);
+    // Check if engine exists
+    if (!(await pathExists(paths.engine))) {
+        throw new GeneralError('Firefox source not found. Run "fireforge download" first.');
+    }
+    // Ensure the engine repo has an "origin" remote so Firefox's bootstrap
+    // scripts don't emit noisy "No such remote" errors.
+    await ensureOriginRemote(paths.engine);
+    info('Installing Firefox build dependencies...');
+    info('This may take a while and require sudo permissions.\n');
+    const result = await bootstrapWithOutput(paths.engine);
+    if (result.exitCode !== 0) {
+        error('Bootstrap failed');
+        const failureMessage = buildBootstrapFailureMessage(`${result.stdout}\n${result.stderr}`);
+        if (failureMessage) {
+            throw new GeneralError(failureMessage);
+        }
+        throw new BootstrapError();
+    }
+    // mach bootstrap may exit 0 even when sub-downloads fail (e.g. HTTP 403).
+    // Scan output for known failure patterns and surface them as warnings.
+    const softFailure = buildBootstrapFailureMessage(`${result.stdout}\n${result.stderr}`);
+    if (softFailure) {
+        info('');
+        info(softFailure);
+        info('Bootstrap exited successfully but the issues above may cause build failures.');
+    }
+    outro('Build dependencies installed successfully!');
+}
+/** Registers the bootstrap command on the CLI program. */
+export function registerBootstrap(program, { getProjectRoot, withErrorHandling }) {
+    program
+        .command('bootstrap')
+        .description('Install Firefox build dependencies')
+        .action(withErrorHandling(async () => {
+        await bootstrapCommand(getProjectRoot());
+    }));
+}
+//# sourceMappingURL=bootstrap.js.map

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

@@ -0,0 +1,11 @@
+import { Command } from 'commander';
+import type { CommandContext } from '../types/cli.js';
+import type { BuildOptions } from '../types/commands/index.js';
+/**
+ * Runs the build command.
+ * @param projectRoot - Root directory of the project
+ * @param options - Build options
+ */
+export declare function buildCommand(projectRoot: string, options: BuildOptions): Promise<void>;
+/** Registers the build command on the CLI program. */
+export declare function registerBuild(program: Command, { getProjectRoot, withErrorHandling }: CommandContext): void;

package/dist/src/commands/build.js

@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { InvalidArgumentError as CommanderInvalidArgumentError } from 'commander';
+import { validateBrandOverride } from '../core/brand-validation.js';
+import { prepareBuildEnvironment } from '../core/build-prepare.js';
+import { getProjectPaths, loadConfig } from '../core/config.js';
+import { build, buildArtifactMismatchMessage, buildUI, hasBuildArtifacts } from '../core/mach.js';
+import { GeneralError } from '../errors/base.js';
+import { BuildError } from '../errors/build.js';
+import { pathExists } from '../utils/fs.js';
+import { error, info, intro, outro, verbose } from '../utils/logger.js';
+import { pickDefined } from '../utils/options.js';
+import { isPositiveInteger } from '../utils/validation.js';
+function parseJobCount(value) {
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed) || parsed < 1) {
+        throw new CommanderInvalidArgumentError('jobs must be a positive integer');
+    }
+    return parsed;
+}
+function resolveJobCount(options, configJobs) {
+    const jobs = options.jobs ?? configJobs;
+    if (jobs === undefined) {
+        return undefined;
+    }
+    if (!isPositiveInteger(jobs)) {
+        throw new GeneralError('Build jobs must be a positive integer');
+    }
+    return jobs;
+}
+/**
+ * Runs the build command.
+ * @param projectRoot - Root directory of the project
+ * @param options - Build options
+ */
+export async function buildCommand(projectRoot, options) {
+    const buildType = options.ui ? 'UI-only' : 'Full';
+    const brandInfo = options.brand ? ` [${options.brand}]` : '';
+    intro(`FireForge Build (${buildType}${brandInfo})`);
+    // Load configuration
+    const config = await loadConfig(projectRoot);
+    const paths = getProjectPaths(projectRoot);
+    validateBrandOverride(config.binaryName, options.brand);
+    // Check if engine exists
+    if (!(await pathExists(paths.engine))) {
+        throw new GeneralError('Firefox source not found. Run "fireforge download" first.');
+    }
+    const buildCheck = await hasBuildArtifacts(paths.engine);
+    const mismatchMessage = buildArtifactMismatchMessage(paths.engine, buildCheck, 'Build');
+    if (mismatchMessage) {
+        throw new GeneralError(mismatchMessage);
+    }
+    // Log brand info if specified
+    if (options.brand) {
+        verbose(`Building with brand: ${options.brand}`);
+        // Future: Load brand-specific config from fireforge.json brands section
+        info(`Brand: ${options.brand}`);
+    }
+    // Shared pre-flight: branding, Furnace, mozconfig
+    await prepareBuildEnvironment(projectRoot, paths, config);
+    const jobs = resolveJobCount(options, config.build?.jobs);
+    // Run build
+    info(`Starting ${buildType.toLowerCase()} build...`);
+    if (jobs !== undefined) {
+        info(`Using ${jobs} parallel jobs`);
+    }
+    info(''); // Empty line before build output
+    const startTime = Date.now();
+    let exitCode;
+    try {
+        if (options.ui) {
+            exitCode = await buildUI(paths.engine);
+        }
+        else {
+            exitCode = await build(paths.engine, jobs);
+        }
+    }
+    catch (error) {
+        throw new BuildError('Build process failed to start', options.ui ? 'mach build faster' : 'mach build', error instanceof Error ? error : undefined);
+    }
+    const duration = Date.now() - startTime;
+    const minutes = Math.floor(duration / 60000);
+    const seconds = Math.floor((duration % 60000) / 1000);
+    const timeStr = minutes > 0 ? `${minutes}m ${seconds}s` : `${seconds}s`;
+    if (exitCode !== 0) {
+        error(`Build failed after ${timeStr}`);
+        throw new BuildError(`Build failed with exit code ${exitCode}`, options.ui ? 'mach build faster' : 'mach build');
+    }
+    outro(`Build completed in ${timeStr}!`);
+}
+/** Registers the build command on the CLI program. */
+export function registerBuild(program, { getProjectRoot, withErrorHandling }) {
+    program
+        .command('build')
+        .description('Build the browser')
+        .option('--ui', 'Fast UI-only rebuild')
+        .option('-j, --jobs <n>', 'Number of parallel jobs', parseJobCount)
+        .option('--brand <name>', 'Build specific brand')
+        .action(withErrorHandling(async (options) => {
+        await buildCommand(getProjectRoot(), pickDefined(options));
+    }));
+}
+//# sourceMappingURL=build.js.map

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

@@ -0,0 +1,13 @@
+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/config.js

@@ -0,0 +1,135 @@
+import { configExists, loadConfig, mutateConfig, SUPPORTED_CONFIG_PATHS, SUPPORTED_CONFIG_ROOT_KEYS, writeConfig, writeConfigDocument, } from '../core/config.js';
+import { GeneralError, InvalidArgumentError } from '../errors/base.js';
+import { toError } from '../utils/errors.js';
+import { info, intro, outro, success, warn } from '../utils/logger.js';
+import { pickDefined } from '../utils/options.js';
+/**
+ * Gets a nested value from an object using dot notation.
+ * @param obj - Object to traverse
+ * @param path - Dot-separated path (e.g., "firefox.version")
+ * @returns The value at the path, or undefined if not found
+ */
+function getNestedValue(obj, path) {
+    const parts = path.split('.');
+    let current = obj;
+    for (const part of parts) {
+        if (current === null || current === undefined) {
+            return undefined;
+        }
+        if (typeof current !== 'object') {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+/** Config keys that must always be stored as strings. */
+const STRING_TYPED_KEYS = new Set([
+    'name',
+    'vendor',
+    'appId',
+    'binaryName',
+    'firefox.version',
+    'firefox.product',
+    'license',
+    'wire.subscriptDir',
+]);
+/**
+ * Parses a string value into the appropriate type.
+ * Keys listed in STRING_TYPED_KEYS are always stored as strings to prevent
+ * accidental type coercion (e.g. `fireforge config firefox.version 128` would
+ * otherwise become the number 128 instead of the string "128").
+ */
+function parseValue(value, key) {
+    // For known string-typed keys, always return as string
+    if (key && STRING_TYPED_KEYS.has(key)) {
+        return value;
+    }
+    // Try to parse as JSON first (handles numbers, booleans, arrays, objects).
+    try {
+        const parsed = JSON.parse(value);
+        if (typeof parsed !== 'string') {
+            warn(`Value "${value}" was interpreted as ${typeof parsed}. Use '"${value}"' for a string.`);
+        }
+        return parsed;
+    }
+    catch (error) {
+        void error;
+        // Fall back to string
+        return value;
+    }
+}
+/**
+ * Formats a value for display.
+ */
+function formatValue(value) {
+    if (value === undefined) {
+        return '(not set)';
+    }
+    if (value === null || typeof value === 'object' || typeof value === 'function') {
+        return JSON.stringify(value, null, 2);
+    }
+    return String(value);
+}
+/**
+ * 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 async function configCommand(projectRoot, key, value, options = {}) {
+    intro('FireForge Config');
+    // Check if config exists
+    if (!(await configExists(projectRoot))) {
+        throw new GeneralError('No fireforge.json found. Run "fireforge setup" to create a project.');
+    }
+    const config = await loadConfig(projectRoot);
+    if (value === undefined) {
+        // Get mode
+        const currentValue = getNestedValue(config, key);
+        if (currentValue === undefined) {
+            throw new InvalidArgumentError(`Unknown config key: ${key}`);
+        }
+        else {
+            info(`${key} = ${formatValue(currentValue)}`);
+        }
+    }
+    else {
+        // Set mode — validate key prefix
+        const topLevelKey = key.split('.')[0] ?? key;
+        if (!SUPPORTED_CONFIG_ROOT_KEYS.includes(topLevelKey) &&
+            !options.force) {
+            throw new InvalidArgumentError(`Unknown config key prefix: "${topLevelKey}". Known keys: ${SUPPORTED_CONFIG_ROOT_KEYS.join(', ')}. Use --force to set anyway.`);
+        }
+        if (!SUPPORTED_CONFIG_PATHS.includes(key) && !options.force) {
+            throw new InvalidArgumentError(`Unknown config key: "${key}". Known keys: ${SUPPORTED_CONFIG_PATHS.join(', ')}. Use --force to set anyway.`);
+        }
+        const parsedValue = parseValue(value, key);
+        try {
+            if (options.force) {
+                const updatedConfig = mutateConfig(config, key, parsedValue, true);
+                await writeConfigDocument(projectRoot, updatedConfig);
+            }
+            else {
+                const updatedConfig = mutateConfig(config, key, parsedValue);
+                await writeConfig(projectRoot, updatedConfig);
+            }
+        }
+        catch (error) {
+            throw new InvalidArgumentError(`Invalid value for "${key}": ${toError(error).message}`, key);
+        }
+        success(`Set ${key} = ${formatValue(parsedValue)}`);
+    }
+    outro('');
+}
+/** Registers the config command on the CLI program. */
+export function registerConfig(program, { getProjectRoot, withErrorHandling }) {
+    program
+        .command('config <key> [value]')
+        .description('Get or set configuration values')
+        .option('-f, --force', 'Allow setting unknown config keys')
+        .action(withErrorHandling(async (key, value, options) => {
+        await configCommand(getProjectRoot(), key, value, pickDefined(options));
+    }));
+}
+//# sourceMappingURL=config.js.map

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

@@ -0,0 +1,12 @@
+import { Command } from 'commander';
+import type { CommandContext } from '../types/cli.js';
+import type { DiscardOptions } from '../types/commands/index.js';
+/**
+ * Runs the discard command to revert changes to a specific file.
+ * @param projectRoot - Root directory of the project
+ * @param file - File path to discard (relative to engine/)
+ * @param options - Discard options
+ */
+export declare function discardCommand(projectRoot: string, file: string, options?: DiscardOptions): Promise<void>;
+/** Registers the discard command on the CLI program. */
+export declare function registerDiscard(program: Command, { getProjectRoot, withErrorHandling }: CommandContext): void;

package/dist/src/commands/discard.js

@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { confirm } from '@clack/prompts';
+import { getProjectPaths } from '../core/config.js';
+import { isGitRepository } from '../core/git.js';
+import { discardStatusEntry } from '../core/git-file-ops.js';
+import { expandUntrackedDirectoryEntries, getWorkingTreeStatus } from '../core/git-status.js';
+import { GeneralError, InvalidArgumentError } from '../errors/base.js';
+import { GitError } from '../errors/git.js';
+import { pathExists } from '../utils/fs.js';
+import { info, intro, isCancel, outro, spinner } from '../utils/logger.js';
+import { pickDefined } from '../utils/options.js';
+/**
+ * Runs the discard command to revert changes to a specific file.
+ * @param projectRoot - Root directory of the project
+ * @param file - File path to discard (relative to engine/)
+ * @param options - Discard options
+ */
+export async function discardCommand(projectRoot, file, options = {}) {
+    intro('FireForge Discard');
+    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.');
+    }
+    // Check if the file has changes
+    const statusEntries = await expandUntrackedDirectoryEntries(paths.engine, await getWorkingTreeStatus(paths.engine));
+    const statusEntry = statusEntries.find((entry) => entry.file === file || entry.originalPath === file);
+    if (!statusEntry) {
+        throw new GeneralError(`File "${file}" has no changes to discard.`);
+    }
+    if (!options.force && !options.dryRun) {
+        const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
+        if (!isInteractive) {
+            throw new InvalidArgumentError('Interactive confirmation not available. Use --force flag to discard without confirmation.', 'Use: fireforge discard <file> --force');
+        }
+        const confirmed = await confirm({
+            message: `Discard all changes to ${statusEntry.file}?`,
+            initialValue: false,
+        });
+        if (isCancel(confirmed) || !confirmed) {
+            outro('Discard cancelled');
+            return;
+        }
+    }
+    if (options.dryRun) {
+        const target = statusEntry.originalPath === file
+            ? `${statusEntry.originalPath} -> ${statusEntry.file}`
+            : statusEntry.file;
+        info(`Would discard changes to: ${target}`);
+        outro('Dry run complete — no changes made');
+        return;
+    }
+    const s = spinner(`Discarding changes to ${file}...`);
+    try {
+        await discardStatusEntry(paths.engine, statusEntry);
+        s.stop(`Discarded changes to ${file}`);
+        outro('File restored to original state');
+    }
+    catch (error) {
+        s.error('Discard failed');
+        if (error instanceof GitError) {
+            throw error;
+        }
+        throw new GitError(`Failed to discard ${file}`, statusEntry.isUntracked
+            ? `rm ${statusEntry.file}`
+            : `restore --source HEAD --staged --worktree -- ${statusEntry.file}`, error instanceof Error ? error : undefined);
+    }
+}
+/** Registers the discard command on the CLI program. */
+export function registerDiscard(program, { getProjectRoot, withErrorHandling }) {
+    program
+        .command('discard <file>')
+        .description('Discard changes to a specific file (deletes untracked files)')
+        .option('--dry-run', 'Show what would be discarded without doing it')
+        .option('--force', 'Skip confirmation prompt')
+        .action(withErrorHandling(async (file, options) => {
+        await discardCommand(getProjectRoot(), file, pickDefined(options));
+    }));
+}
+//# sourceMappingURL=discard.js.map

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

@@ -0,0 +1,18 @@
+import { Command } from 'commander';
+import type { CommandContext } from '../types/cli.js';
+import type { DoctorCheck, DoctorOptions } from '../types/commands/index.js';
+/**
+ * Result of the doctor command, carrying the exit code so the caller
+ * (or test) can inspect it without relying on process.exitCode.
+ */
+export interface DoctorResult {
+    checks: DoctorCheck[];
+    exitCode: number;
+}
+/**
+ * Runs the doctor command to diagnose issues.
+ * @param projectRoot - Root directory of the project
+ */
+export declare function doctorCommand(projectRoot: string, options?: DoctorOptions): Promise<DoctorResult>;
+/** Registers the doctor command on the CLI program. */
+export declare function registerDoctor(program: Command, { getProjectRoot, withErrorHandling }: CommandContext): void;