@hominis/fireforge 0.9.0

package/dist/src/commands/doctor.js

@@ -0,0 +1,356 @@
+import { configExists, getProjectPaths, loadConfig, loadState } from '../core/config.js';
+import { getCurrentBranch, getHead, isGitRepository, isMissingHeadError } from '../core/git.js';
+import { ensureGit } from '../core/git-base.js';
+import { expandUntrackedDirectoryEntries, getWorkingTreeStatus } from '../core/git-status.js';
+import { ensureMach, ensurePython } from '../core/mach.js';
+import { countPatches } from '../core/patch-apply.js';
+import { rebuildPatchesManifest, validatePatchesManifestConsistency, validatePatchIntegrity, } from '../core/patch-manifest.js';
+import { ExitCode } from '../errors/codes.js';
+import { toError } from '../utils/errors.js';
+import { pathExists } from '../utils/fs.js';
+import { error, info, intro, outro, success, warn } from '../utils/logger.js';
+/**
+ * Runs a doctor check and returns the result.
+ */
+async function runCheck(name, check, fix) {
+    try {
+        await check();
+        return { name, passed: true, severity: 'ok', message: 'OK' };
+    }
+    catch (error) {
+        const message = toError(error).message;
+        const result = { name, passed: false, severity: 'error', message };
+        if (fix !== undefined) {
+            result.fix = fix;
+        }
+        return result;
+    }
+}
+function summarizeWorkingTreeChangeCount(changeCount) {
+    return `Engine working tree has ${changeCount} local change${changeCount === 1 ? '' : 's'}. Some FireForge commands assume a clean baseline and may behave differently until these are exported, discarded, or committed.`;
+}
+async function collectEngineChecks(paths, state, engineExists) {
+    const checks = [];
+    if (!engineExists) {
+        return checks;
+    }
+    // Check 6: Engine is a git repository
+    const isGitRepo = await isGitRepository(paths.engine);
+    checks.push({
+        name: 'Engine is git repository',
+        passed: isGitRepo,
+        severity: isGitRepo ? 'ok' : 'error',
+        message: isGitRepo ? 'OK' : 'engine/ is not a git repository',
+        ...(!isGitRepo ? { fix: 'Run "fireforge download --force" to reinitialize' } : {}),
+    });
+    // Only run git-dependent checks if the engine is actually a git repo
+    if (isGitRepo) {
+        let currentHead;
+        let canValidateBranch = true;
+        // Engine consistency checks
+        if (state.baseCommit) {
+            try {
+                currentHead = await getHead(paths.engine);
+            }
+            catch (error) {
+                if (!isMissingHeadError(error)) {
+                    throw error;
+                }
+                canValidateBranch = false;
+                checks.push({
+                    name: 'Engine state consistency',
+                    passed: false,
+                    severity: 'error',
+                    message: 'Engine repository has no baseline commit yet. A previous "fireforge download" likely stopped after git init but before the initial Firefox commit was created.',
+                    fix: 'Re-run "fireforge download --force" to recreate the baseline repository cleanly.',
+                });
+            }
+            if (canValidateBranch && currentHead !== state.baseCommit) {
+                checks.push({
+                    name: 'Engine state consistency',
+                    passed: false,
+                    severity: 'error',
+                    message: 'HEAD differs from baseCommit. FireForge expects the engine repository to remain at the downloaded baseline commit; branch switches or commits inside engine/ can break import, resolve, and patch regeneration workflows.',
+                    fix: 'Reset engine/ to the baseline commit or re-run "fireforge download --force".',
+                });
+            }
+            else if (canValidateBranch) {
+                checks.push({
+                    name: 'Engine state consistency',
+                    passed: true,
+                    severity: 'ok',
+                    message: 'OK',
+                });
+            }
+        }
+        const rawStatus = await getWorkingTreeStatus(paths.engine);
+        const workingTreeStatus = await expandUntrackedDirectoryEntries(paths.engine, rawStatus);
+        if (workingTreeStatus.length > 0) {
+            checks.push({
+                name: 'Engine working tree',
+                passed: true,
+                severity: 'warning',
+                warning: true,
+                message: summarizeWorkingTreeChangeCount(workingTreeStatus.length),
+                fix: 'Use "fireforge status" to review changes, then export, discard, or reset them as appropriate.',
+            });
+        }
+        else {
+            checks.push({
+                name: 'Engine working tree',
+                passed: true,
+                severity: 'ok',
+                message: 'OK',
+            });
+        }
+        let branch;
+        if (canValidateBranch) {
+            try {
+                branch = await getCurrentBranch(paths.engine);
+            }
+            catch (error) {
+                if (!isMissingHeadError(error)) {
+                    throw error;
+                }
+                canValidateBranch = false;
+                checks.push({
+                    name: 'Engine branch',
+                    passed: false,
+                    severity: 'error',
+                    message: 'Engine repository has no baseline commit yet. A previous "fireforge download" likely stopped before git created the initial Firefox commit.',
+                    fix: 'Re-run "fireforge download --force" to recreate the baseline repository cleanly.',
+                });
+            }
+        }
+        if (!canValidateBranch &&
+            branch === undefined &&
+            currentHead === undefined &&
+            !state.baseCommit) {
+            // An unborn repository can fail branch detection before state.json records baseCommit.
+            // The error above already explains the recovery path, so avoid adding extra noise here.
+        }
+        else if (!canValidateBranch) {
+            checks.push({
+                name: 'Engine branch',
+                passed: true,
+                severity: 'warning',
+                warning: true,
+                message: 'Skipped branch validation because the baseline commit is missing.',
+                fix: 'Finish recreating the engine baseline with "fireforge download --force".',
+            });
+        }
+        else if (branch === 'firefox') {
+            checks.push({
+                name: 'Engine branch',
+                passed: true,
+                severity: 'ok',
+                message: 'OK',
+            });
+        }
+        else if (branch === 'HEAD' && state.baseCommit && currentHead === state.baseCommit) {
+            checks.push({
+                name: 'Engine branch',
+                passed: true,
+                severity: 'warning',
+                warning: true,
+                message: 'Engine is detached at the recorded base commit. This is acceptable for disposable worktrees and audit clones.',
+                fix: 'If this is your primary workspace, checkout the "firefox" branch to match FireForge defaults.',
+            });
+        }
+        else {
+            checks.push({
+                name: 'Engine branch',
+                passed: false,
+                severity: 'error',
+                message: `Engine is on branch "${branch}", but expected "firefox".`,
+            });
+        }
+    }
+    // Check 7: mach available
+    checks.push(await runCheck('mach available', async () => {
+        await ensureMach(paths.engine);
+    }, 'Firefox source may be corrupted. Re-download with "fireforge download --force"'));
+    return checks;
+}
+function reportDoctorResults(checks) {
+    info('');
+    let passedCount = 0;
+    let warningCount = 0;
+    let failedCount = 0;
+    for (const check of checks) {
+        const severity = check.severity ?? (check.passed ? (check.warning ? 'warning' : 'ok') : 'error');
+        if (severity === 'warning') {
+            warn(`! ${check.name}: ${check.message}`);
+            if (check.fix) {
+                warn(`  Fix: ${check.fix}`);
+            }
+            warningCount++;
+        }
+        else if (severity === 'ok') {
+            success(`✓ ${check.name}: ${check.message}`);
+            passedCount++;
+        }
+        else {
+            error(`✗ ${check.name}: ${check.message}`);
+            if (check.fix) {
+                warn(`  Fix: ${check.fix}`);
+            }
+            failedCount++;
+        }
+    }
+    info('');
+    if (failedCount === 0 && warningCount === 0) {
+        outro(`All ${passedCount} checks passed!`);
+    }
+    else if (failedCount === 0) {
+        outro(`${passedCount} passed, ${warningCount} warning${warningCount === 1 ? '' : 's'}`);
+    }
+    else {
+        outro(`${passedCount} passed, ${warningCount} warning${warningCount === 1 ? '' : 's'}, ${failedCount} failed`);
+        return ExitCode.GENERAL_ERROR;
+    }
+    return ExitCode.SUCCESS;
+}
+async function collectProjectChecks(paths, engineExists, firefoxVersion, options) {
+    const checks = [];
+    const patchesExist = await pathExists(paths.patches);
+    checks.push({
+        name: 'Patches directory exists',
+        passed: true,
+        severity: 'ok',
+        message: patchesExist ? 'OK' : 'No patches/ directory (optional)',
+    });
+    if (patchesExist) {
+        const patchCount = await countPatches(paths.patches);
+        checks.push({
+            name: 'Patches found',
+            passed: true,
+            severity: 'ok',
+            message: `${patchCount} patch${patchCount === 1 ? '' : 'es'} found`,
+        });
+        const manifestConsistencyIssues = await validatePatchesManifestConsistency(paths.patches);
+        if (manifestConsistencyIssues.length > 0) {
+            if (options.repairPatchesManifest) {
+                try {
+                    const repairedManifest = await rebuildPatchesManifest(paths.patches, firefoxVersion ?? 'unknown');
+                    checks.push({
+                        name: 'Patch manifest consistency',
+                        passed: true,
+                        severity: 'warning',
+                        warning: true,
+                        message: `Rebuilt patches.json from ${repairedManifest.patches.length} patch` +
+                            `${repairedManifest.patches.length === 1 ? '' : 'es'}. Review recovered metadata before release.`,
+                    });
+                }
+                catch (error) {
+                    checks.push({
+                        name: 'Patch manifest consistency',
+                        passed: false,
+                        severity: 'error',
+                        message: toError(error).message,
+                        fix: 'Repair failed. Fix the underlying patch metadata issue and retry the doctor command.',
+                    });
+                }
+            }
+            else {
+                checks.push({
+                    name: 'Patch manifest consistency',
+                    passed: false,
+                    severity: 'error',
+                    message: manifestConsistencyIssues.map((issue) => issue.message).join(' '),
+                    fix: 'Run "fireforge doctor --repair-patches-manifest" to rebuild patches.json from patch files.',
+                });
+            }
+        }
+        else {
+            checks.push({
+                name: 'Patch manifest consistency',
+                passed: true,
+                severity: 'ok',
+                message: 'OK',
+            });
+        }
+        if (engineExists) {
+            checks.push(await runCheck('Patch integrity', async () => {
+                const issues = await validatePatchIntegrity(paths.patches, paths.engine);
+                if (issues.length > 0) {
+                    const fileList = issues.map((issue) => issue.targetFile).filter(Boolean);
+                    throw new Error(`${issues.length} patch(es) are modification patches for non-existent files: ${fileList.join(', ')}`);
+                }
+            }, 'Re-export affected files with "fireforge export <paths...>" to create full-file patches'));
+        }
+    }
+    const configsExist = await pathExists(paths.configs);
+    checks.push(await runCheck('Configs directory exists', () => {
+        if (!configsExist) {
+            throw new Error('configs/ directory not found');
+        }
+    }, 'Run "fireforge setup" to create configs'));
+    return checks;
+}
+/**
+ * Runs the doctor command to diagnose issues.
+ * @param projectRoot - Root directory of the project
+ */
+export async function doctorCommand(projectRoot, options = {}) {
+    intro('FireForge Doctor');
+    const checks = [];
+    const paths = getProjectPaths(projectRoot);
+    const state = await loadState(projectRoot);
+    let config;
+    // Check 1: Git installed
+    checks.push(await runCheck('Git installed', async () => {
+        await ensureGit();
+    }, 'Install git from https://git-scm.com/'));
+    // Check 2: Python supported by mach
+    checks.push(await runCheck('Python supported by mach', async () => {
+        await ensurePython(paths.engine);
+    }, 'Install a Python version supported by engine/mach, then re-run "fireforge doctor".'));
+    // Check 3: fireforge.json exists
+    checks.push(await runCheck('fireforge.json exists', async () => {
+        if (!(await configExists(projectRoot))) {
+            throw new Error('fireforge.json not found');
+        }
+    }, 'Run "fireforge setup" to create a project'));
+    // Check 4: fireforge.json is valid
+    checks.push(await runCheck('fireforge.json is valid', async () => {
+        config = await loadConfig(projectRoot);
+    }, 'Check fireforge.json for syntax errors or missing fields'));
+    // Check 5: Engine directory exists
+    const engineExists = await pathExists(paths.engine);
+    checks.push(await runCheck('Engine directory exists', () => {
+        if (!engineExists) {
+            throw new Error('engine/ directory not found');
+        }
+    }, 'Run "fireforge download" to download Firefox source'));
+    // Check: Pending Resolution
+    if (state.pendingResolution) {
+        checks.push({
+            name: 'Pending Resolution',
+            passed: false,
+            severity: 'error',
+            message: `You are currently resolving a conflict for patch ${state.pendingResolution.patchFilename}.`,
+            fix: 'Build and Export commands may behave unexpectedly until "fireforge resolve" is completed.',
+        });
+    }
+    // Engine checks (git repo, state consistency, working tree, branch, mach)
+    checks.push(...(await collectEngineChecks(paths, state, engineExists)));
+    checks.push(...(await collectProjectChecks(paths, engineExists, config?.firefox.version, options)));
+    // Display results and return
+    const exitCode = reportDoctorResults(checks);
+    return { checks, exitCode };
+}
+/** Registers the doctor command on the CLI program. */
+export function registerDoctor(program, { getProjectRoot, withErrorHandling }) {
+    program
+        .command('doctor')
+        .description('Diagnose project issues')
+        .option('--repair-patches-manifest', 'Rebuild patches/patches.json from the current patch files before reporting results')
+        .action(withErrorHandling(async (options) => {
+        const result = await doctorCommand(getProjectRoot(), options);
+        if (result.exitCode !== 0) {
+            process.exitCode = result.exitCode;
+        }
+    }));
+}
+//# sourceMappingURL=doctor.js.map

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

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

package/dist/src/commands/download.js

@@ -0,0 +1,127 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { join } from 'node:path';
+import { getProjectPaths, loadConfig, updateState } from '../core/config.js';
+import { downloadFirefoxSource, formatBytes } from '../core/firefox.js';
+import { getHead, initRepository, isGitRepository, isMissingHeadError, resumeRepository, } from '../core/git.js';
+import { EngineExistsError, PartialEngineExistsError } from '../errors/download.js';
+import { ensureDir, pathExists, removeDir } from '../utils/fs.js';
+import { info, intro, outro, spinner, step, warn } from '../utils/logger.js';
+import { pickDefined } from '../utils/options.js';
+/**
+ * Runs the download command.
+ * @param projectRoot - Root directory of the project
+ * @param options - Download options
+ */
+export async function downloadCommand(projectRoot, options) {
+    intro('FireForge Download');
+    // Load configuration
+    const config = await loadConfig(projectRoot);
+    const paths = getProjectPaths(projectRoot);
+    const version = config.firefox.version;
+    info(`Firefox version: ${version}`);
+    // Check if engine already exists
+    if (await pathExists(paths.engine)) {
+        if (!options.force) {
+            if (await isGitRepository(paths.engine)) {
+                try {
+                    await getHead(paths.engine);
+                }
+                catch (error) {
+                    if (isMissingHeadError(error)) {
+                        // Partial init detected — attempt to resume instead of requiring --force
+                        info('Detected partially initialized engine. Attempting to resume...');
+                        const resumeSpinner = spinner('Resuming git repository initialization...');
+                        try {
+                            await resumeRepository(paths.engine, {
+                                onProgress: (message) => {
+                                    resumeSpinner.message(message);
+                                    if (!(process.stdout.isTTY && process.stderr.isTTY)) {
+                                        step(message);
+                                    }
+                                },
+                            });
+                            const baseCommit = await getHead(paths.engine);
+                            resumeSpinner.stop('Git repository resumed successfully');
+                            await updateState(projectRoot, {
+                                downloadedVersion: version,
+                                baseCommit,
+                            });
+                            outro(`Firefox ${version} is ready! (resumed from partial init)`);
+                            return;
+                        }
+                        catch (error) {
+                            void error;
+                            resumeSpinner.error('Resume failed');
+                            throw new PartialEngineExistsError(paths.engine);
+                        }
+                    }
+                    // Re-throw unexpected git errors (e.g. corrupted objects) rather
+                    // than masking them behind the generic EngineExistsError below.
+                    throw error;
+                }
+            }
+            throw new EngineExistsError(paths.engine);
+        }
+        warn('Removing existing engine directory...');
+        await removeDir(paths.engine);
+    }
+    // Ensure cache directory exists
+    const cacheDir = join(paths.fireforgeDir, 'cache');
+    await ensureDir(cacheDir);
+    // Download with progress
+    const s = spinner(`Downloading Firefox ${version}...`);
+    let lastPercent = 0;
+    try {
+        await downloadFirefoxSource(version, config.firefox.product, paths.engine, cacheDir, (downloaded, total) => {
+            if (total <= 0)
+                return;
+            const percent = Math.floor((downloaded / total) * 100);
+            if (percent !== lastPercent && percent % 5 === 0) {
+                s.message(`Downloading Firefox ${version}... ${percent}% (${formatBytes(downloaded)} / ${formatBytes(total)})`);
+                lastPercent = percent;
+            }
+        });
+        s.stop(`Firefox ${version} downloaded`);
+    }
+    catch (error) {
+        s.error('Download failed');
+        throw error;
+    }
+    // Initialize git repository
+    const gitSpinner = spinner('Initializing git repository (this may take a few minutes)...');
+    let baseCommit;
+    try {
+        await initRepository(paths.engine, 'firefox', {
+            onProgress: (message) => {
+                gitSpinner.message(message);
+                if (!(process.stdout.isTTY && process.stderr.isTTY)) {
+                    step(message);
+                }
+            },
+        });
+        baseCommit = await getHead(paths.engine);
+        gitSpinner.stop('Git repository initialized');
+    }
+    catch (error) {
+        gitSpinner.error('Failed to initialize git repository');
+        warn('engine/ may now contain a partially initialized git repository. Re-run "fireforge download --force" to recreate the baseline cleanly.');
+        throw error;
+    }
+    // Update state
+    await updateState(projectRoot, {
+        downloadedVersion: version,
+        baseCommit,
+    });
+    outro(`Firefox ${version} is ready!`);
+}
+/** Registers the download command on the CLI program. */
+export function registerDownload(program, { getProjectRoot, withErrorHandling }) {
+    program
+        .command('download')
+        .description('Download Firefox source')
+        .option('-f, --force', 'Force re-download, removing existing source')
+        .action(withErrorHandling(async (options) => {
+        await downloadCommand(getProjectRoot(), pickDefined(options));
+    }));
+}
+//# sourceMappingURL=download.js.map

package/dist/src/commands/export-all.d.ts

@@ -0,0 +1,11 @@
+import { Command } from 'commander';
+import type { CommandContext } from '../types/cli.js';
+import type { ExportOptions } from '../types/commands/index.js';
+/**
+ * Runs the export-all command to export all changes as a patch.
+ * @param projectRoot - Root directory of the project
+ * @param options - Export options
+ */
+export declare function exportAllCommand(projectRoot: string, options?: ExportOptions): Promise<void>;
+/** Registers the export-all command on the CLI program. */
+export declare function registerExportAll(program: Command, { getProjectRoot, withErrorHandling }: CommandContext): void;

package/dist/src/commands/export-all.js

@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { Option } from 'commander';
+import { isBrandingManagedPath } from '../core/branding.js';
+import { getProjectPaths, loadConfig } from '../core/config.js';
+import { hasChanges, isGitRepository } from '../core/git.js';
+import { getAllDiff } from '../core/git-diff.js';
+import { getWorkingTreeStatus } from '../core/git-status.js';
+import { extractAffectedFiles } from '../core/patch-apply.js';
+import { commitExportedPatch } from '../core/patch-export.js';
+import { GeneralError } from '../errors/base.js';
+import { ensureDir, pathExists } from '../utils/fs.js';
+import { info, intro, outro, spinner } from '../utils/logger.js';
+import { pickDefined } from '../utils/options.js';
+import { PATCH_CATEGORIES } from '../utils/validation.js';
+import { autoFixLicenseHeaders, confirmSupersedePatches, promptExportPatchMetadata, runPatchLint, } from './export-shared.js';
+async function checkBrandingManagedFiles(paths, config) {
+    const changedFiles = await getWorkingTreeStatus(paths.engine);
+    const brandingManagedFiles = changedFiles
+        .flatMap((entry) => [entry.file, entry.originalPath].filter((value) => !!value))
+        .filter((file) => isBrandingManagedPath(file, config.binaryName));
+    if (brandingManagedFiles.length > 0) {
+        throw new GeneralError('Export-all refuses to capture tool-managed branding changes by default.\n\n' +
+            'Review these files with "fireforge status" first. If you intentionally want a branding patch, export the specific branding paths explicitly with "fireforge export ...".');
+    }
+}
+/**
+ * Runs the export-all command to export all changes as a patch.
+ * @param projectRoot - Root directory of the project
+ * @param options - Export options
+ */
+export async function exportAllCommand(projectRoot, options = {}) {
+    intro('FireForge Export All');
+    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 for changes
+    if (!(await hasChanges(paths.engine))) {
+        info('No changes to export');
+        outro('Nothing to export');
+        return;
+    }
+    const config = await loadConfig(projectRoot);
+    await checkBrandingManagedFiles(paths, config);
+    // Get the full diff
+    let diff = await getAllDiff(paths.engine);
+    if (!diff.trim()) {
+        info('No diff content to export');
+        outro('Nothing to export');
+        return;
+    }
+    // Check for non-interactive mode
+    const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
+    // Auto-fix missing license headers on new files (interactive only)
+    const headersAdded = await autoFixLicenseHeaders(paths.engine, diff, config, isInteractive);
+    if (headersAdded) {
+        diff = await getAllDiff(paths.engine);
+    }
+    const metadata = await promptExportPatchMetadata(options, isInteractive, 'export-all');
+    if (!metadata)
+        return;
+    const { patchName, selectedCategory, description } = metadata;
+    // Ensure patches directory exists
+    await ensureDir(paths.patches);
+    const s = spinner('Exporting all changes...');
+    try {
+        // Extract affected files from diff
+        const filesAffected = extractAffectedFiles(diff);
+        await runPatchLint(paths.engine, filesAffected, diff, config, options.skipLint);
+        // Check how many existing patches would be superseded
+        const shouldProceed = await confirmSupersedePatches(paths.patches, filesAffected, options.supersede, isInteractive, s);
+        if (!shouldProceed)
+            return;
+        // Get Firefox version for metadata
+        const { patchFilename, superseded } = await commitExportedPatch({
+            patchesDir: paths.patches,
+            category: selectedCategory,
+            name: patchName,
+            description,
+            diff,
+            filesAffected,
+            sourceEsrVersion: config.firefox.version,
+        });
+        for (const oldPatch of superseded) {
+            info(`Superseded: ${oldPatch.filename}`);
+        }
+        s.stop(`Exported to ${patchFilename}`);
+        info(`\nPatch saved to: patches/${patchFilename}`);
+        if (filesAffected.length > 0) {
+            info(`Files affected: ${filesAffected.length}`);
+        }
+        outro('Export complete');
+    }
+    catch (error) {
+        s.error('Export failed');
+        throw error;
+    }
+}
+/** Registers the export-all command on the CLI program. */
+export function registerExportAll(program, { getProjectRoot, withErrorHandling }) {
+    program
+        .command('export-all')
+        .description('Export all changes as a patch')
+        .option('--name <name>', 'Name for the patch')
+        .addOption(new Option('-c, --category <category>', 'Patch category').choices([...PATCH_CATEGORIES]))
+        .option('-d, --description <desc>', 'Description of the patch')
+        .option('--supersede', 'Allow superseding multiple existing patches')
+        .option('--skip-lint', 'Skip patch lint checks (downgrade errors to warnings)')
+        .action(withErrorHandling(async (options) => {
+        const { category, ...rest } = options;
+        await exportAllCommand(getProjectRoot(), {
+            ...pickDefined(rest),
+            ...(category !== undefined ? { category: category } : {}),
+        });
+    }));
+}
+//# sourceMappingURL=export-all.js.map

package/dist/src/commands/export-shared.d.ts

@@ -0,0 +1,48 @@
+import type { ExportOptions, PatchCategory } from '../types/commands/index.js';
+import type { FireForgeConfig } from '../types/config.js';
+import type { SpinnerHandle } from '../utils/logger.js';
+/**
+ * Runs the full patch lint pipeline and reports results.
+ * Warnings are always displayed. Errors block the export unless skipLint is true.
+ *
+ * @param engineDir - Engine root directory
+ * @param filesAffected - Files touched by the patch
+ * @param diffContent - Raw unified diff string
+ * @param config - Project configuration
+ * @param skipLint - If true, downgrade errors to warnings
+ */
+export declare function runPatchLint(engineDir: string, filesAffected: string[], diffContent: string, config: FireForgeConfig, skipLint?: boolean): Promise<void>;
+/**
+ * Resolves patch metadata interactively or from flags, with shared validation.
+ * @param options - Export command options
+ * @param isInteractive - Whether interactive prompts are allowed
+ * @param commandName - Command name for error/help text
+ */
+export declare function promptExportPatchMetadata(options: ExportOptions, isInteractive: boolean, commandName: 'export' | 'export-all'): Promise<{
+    patchName: string;
+    selectedCategory: PatchCategory;
+    description: string;
+} | null>;
+/**
+ * Confirms whether an export may supersede existing patches.
+ * @param patchesDir - Patches directory
+ * @param filesAffected - Files touched by the pending export
+ * @param supersede - Explicit supersede flag from CLI options
+ * @param isInteractive - Whether interactive prompts are allowed
+ * @param s - Active spinner handle to stop before prompting
+ */
+export declare function confirmSupersedePatches(patchesDir: string, filesAffected: string[], supersede: boolean | undefined, isInteractive: boolean, s: SpinnerHandle): Promise<boolean>;
+/**
+ * Detects new files missing license headers and offers to add them.
+ *
+ * In interactive mode the user is prompted before any files are modified.
+ * In non-interactive mode the function is a no-op — the existing lint error
+ * will block the export instead.
+ *
+ * @param engineDir - Absolute path to engine directory
+ * @param diffContent - Current unified diff
+ * @param config - Project configuration
+ * @param isInteractive - Whether interactive prompts are available
+ * @returns true if files were modified on disk (caller must regenerate diff)
+ */
+export declare function autoFixLicenseHeaders(engineDir: string, diffContent: string, config: FireForgeConfig, isInteractive: boolean): Promise<boolean>;