@hominis/fireforge 0.9.0

package/dist/src/commands/furnace/status.js

@@ -0,0 +1,137 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { join } from 'node:path';
+import { getProjectPaths } from '../../core/config.js';
+import { extractComponentChecksums, hasComponentChanged } from '../../core/furnace-apply.js';
+import { furnaceConfigExists, getFurnacePaths, loadFurnaceConfig, loadFurnaceState, } from '../../core/furnace-config.js';
+import { checkRegistrationConsistency } from '../../core/furnace-validate-checks.js';
+import { FurnaceError } from '../../errors/furnace.js';
+import { pathExists } from '../../utils/fs.js';
+import { info, intro, note, outro, warn } from '../../utils/logger.js';
+/**
+ * Displays detailed status for a single Furnace component, including registration drift.
+ * @param name - Component tag name to inspect
+ * @param config - Loaded Furnace configuration
+ * @param projectRoot - Root directory of the project
+ */
+async function showDetailedComponentStatus(name, config, projectRoot) {
+    const customConfig = config.custom[name];
+    const overrideConfig = config.overrides[name];
+    if (!customConfig && !overrideConfig && !config.stock.includes(name)) {
+        throw new FurnaceError(`Component "${name}" not found in furnace.json.`, name);
+    }
+    if (overrideConfig) {
+        info(`"${name}" is an override component (${overrideConfig.type}).`);
+        info(`Base path: ${overrideConfig.basePath}`);
+        info(`Base version: ${overrideConfig.baseVersion}`);
+        outro('');
+        return;
+    }
+    if (config.stock.includes(name)) {
+        info(`"${name}" is a stock component. No local registration to check.`);
+        outro('');
+        return;
+    }
+    if (!customConfig) {
+        outro('');
+        return;
+    }
+    // Custom component — run registration consistency check
+    const status = await checkRegistrationConsistency(projectRoot, name, customConfig);
+    const lines = [];
+    const check = (ok, label) => {
+        lines.push(`${ok ? '\u2713' : '\u2717'} ${label}`);
+    };
+    check(status.sourceExists, 'Source directory exists');
+    check(status.targetExists, 'Target directory exists in engine');
+    check(status.filesInSync, 'Source and target files in sync');
+    check(status.jarMnMjs, `jar.mn has ${name}.mjs entry`);
+    check(status.jarMnCss, `jar.mn has ${name}.css entry`);
+    check(status.customElementsPresent, 'Registered in customElements.js');
+    check(status.customElementsCorrectBlock, 'In correct DOMContentLoaded block');
+    if (status.driftedFiles.length > 0) {
+        lines.push(`Drifted files: ${status.driftedFiles.join(', ')}`);
+    }
+    if (status.missingTargetFiles.length > 0) {
+        lines.push(`Missing in engine: ${status.missingTargetFiles.join(', ')}`);
+    }
+    note(lines.join('\n'), `${name} Registration Status`);
+    outro('');
+}
+/**
+ * Runs the furnace status command to show an overview of Furnace state.
+ * When a component name is provided, shows detailed registration status.
+ * @param projectRoot - Root directory of the project
+ * @param name - Optional component name for detailed status
+ */
+export async function furnaceStatusCommand(projectRoot, name) {
+    intro('Furnace');
+    if (!(await furnaceConfigExists(projectRoot))) {
+        info('Furnace is not configured. Run `fireforge furnace create` or `fireforge furnace override` to get started.');
+        outro('');
+        return;
+    }
+    const config = await loadFurnaceConfig(projectRoot);
+    const state = await loadFurnaceState(projectRoot);
+    const paths = getProjectPaths(projectRoot);
+    const furnacePaths = getFurnacePaths(projectRoot);
+    if (name) {
+        await showDetailedComponentStatus(name, config, projectRoot);
+        return;
+    }
+    // --- Overview mode ---
+    const overrideCount = Object.keys(config.overrides).length;
+    const customCount = Object.keys(config.custom).length;
+    const stockCount = config.stock.length;
+    // Build summary lines
+    const lines = [];
+    lines.push(`Component prefix: ${config.componentPrefix || '(none)'}`);
+    lines.push(`Stock components: ${stockCount}`);
+    // Overrides
+    lines.push(`Override components: ${overrideCount}`);
+    if (overrideCount > 0) {
+        for (const [oName, entry] of Object.entries(config.overrides)) {
+            lines.push(`  ${oName} (${entry.type})`);
+        }
+    }
+    // Custom
+    lines.push(`Custom components: ${customCount}`);
+    if (customCount > 0) {
+        for (const cName of Object.keys(config.custom)) {
+            lines.push(`  ${cName}`);
+        }
+    }
+    // Last apply
+    lines.push(`Last apply: ${state.lastApply ?? 'never'}`);
+    note(lines.join('\n'), 'Furnace Status');
+    // Check for changes since last apply
+    if (await pathExists(paths.engine)) {
+        let changesDetected = false;
+        for (const oName of Object.keys(config.overrides)) {
+            const componentDir = join(furnacePaths.overridesDir, oName);
+            if (!(await pathExists(componentDir)))
+                continue;
+            const previous = extractComponentChecksums(state.appliedChecksums, 'override', oName);
+            if (await hasComponentChanged(componentDir, previous)) {
+                changesDetected = true;
+                break;
+            }
+        }
+        if (!changesDetected) {
+            for (const cName of Object.keys(config.custom)) {
+                const componentDir = join(furnacePaths.customDir, cName);
+                if (!(await pathExists(componentDir)))
+                    continue;
+                const previous = extractComponentChecksums(state.appliedChecksums, 'custom', cName);
+                if (await hasComponentChanged(componentDir, previous)) {
+                    changesDetected = true;
+                    break;
+                }
+            }
+        }
+        if (changesDetected) {
+            warn('Components have been modified since last apply. Run `fireforge build` or `fireforge furnace apply`.');
+        }
+    }
+    outro('');
+}
+//# sourceMappingURL=status.js.map

package/dist/src/commands/furnace/validate.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Runs the furnace validate command to perform static analysis on components.
+ * @param projectRoot - Root directory of the project
+ * @param name - Optional component name to validate (validates all if omitted)
+ */
+export declare function furnaceValidateCommand(projectRoot: string, name?: string): Promise<void>;

package/dist/src/commands/furnace/validate.js

@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { join } from 'node:path';
+import { furnaceConfigExists, getFurnacePaths, loadFurnaceConfig, } from '../../core/furnace-config.js';
+import { validateAllComponents, validateComponent } from '../../core/furnace-validate.js';
+import { FurnaceError } from '../../errors/furnace.js';
+import { pathExists } from '../../utils/fs.js';
+import { info, intro, note, outro, success } from '../../utils/logger.js';
+import { displayValidationIssues } from './validation-output.js';
+/**
+ * Runs the furnace validate command to perform static analysis on components.
+ * @param projectRoot - Root directory of the project
+ * @param name - Optional component name to validate (validates all if omitted)
+ */
+export async function furnaceValidateCommand(projectRoot, name) {
+    intro('Furnace Validate');
+    if (!(await furnaceConfigExists(projectRoot))) {
+        throw new FurnaceError('No furnace.json found. Run "fireforge furnace create" or "fireforge furnace override" to get started.');
+    }
+    const config = await loadFurnaceConfig(projectRoot);
+    const furnacePaths = getFurnacePaths(projectRoot);
+    let totalErrors = 0;
+    let totalWarnings = 0;
+    let componentCount;
+    if (name) {
+        // --- Single component validation ---
+        let type;
+        let componentDir;
+        if (name in config.overrides) {
+            type = 'override';
+            componentDir = join(furnacePaths.overridesDir, name);
+        }
+        else if (name in config.custom) {
+            type = 'custom';
+            componentDir = join(furnacePaths.customDir, name);
+        }
+        else if (config.stock.includes(name)) {
+            info(`"${name}" is a stock component. Stock components are not validated locally.`);
+            outro('Validation complete');
+            return;
+        }
+        else {
+            throw new FurnaceError(`Component "${name}" not found in furnace.json.`, name);
+        }
+        if (!(await pathExists(componentDir))) {
+            throw new FurnaceError(`Component directory not found for "${name}".`, name);
+        }
+        const issues = await validateComponent(componentDir, name, type, config, projectRoot);
+        componentCount = 1;
+        if (issues.length === 0) {
+            success(`${name} — all checks passed`);
+        }
+        else {
+            const [e, w] = displayValidationIssues(issues);
+            totalErrors += e;
+            totalWarnings += w;
+        }
+    }
+    else {
+        // --- Validate all components ---
+        const overrideCount = Object.keys(config.overrides).length;
+        const customCount = Object.keys(config.custom).length;
+        if (overrideCount === 0 && customCount === 0) {
+            info('No components to validate.');
+            outro('Done');
+            return;
+        }
+        if (config.stock.length > 0) {
+            info(`Skipping ${config.stock.length} stock component(s) (no local files to validate).`);
+        }
+        const results = await validateAllComponents(projectRoot);
+        componentCount = results.size;
+        for (const [componentName, issues] of results) {
+            if (issues.length === 0) {
+                success(`${componentName} — all checks passed`);
+            }
+            else {
+                const [e, w] = displayValidationIssues(issues);
+                totalErrors += e;
+                totalWarnings += w;
+            }
+        }
+    }
+    // Summary
+    note(`${totalErrors} error(s), ${totalWarnings} warning(s) across ${componentCount} component(s)`, 'Validation Summary');
+    if (totalErrors > 0) {
+        info('Fix the errors above and run "fireforge furnace validate" again.');
+        throw new FurnaceError(`Validation failed with ${totalErrors} error(s).`);
+    }
+    outro('Validation passed');
+}
+//# sourceMappingURL=validate.js.map

package/dist/src/commands/furnace/validation-output.d.ts

@@ -0,0 +1,7 @@
+import type { ValidationIssue } from '../../types/furnace.js';
+/**
+ * Displays validation issues and returns aggregated error and warning counts.
+ * @param issues - Validation issues to render
+ * @returns Tuple of [errorCount, warningCount]
+ */
+export declare function displayValidationIssues(issues: ValidationIssue[]): [number, number];

package/dist/src/commands/furnace/validation-output.js

@@ -0,0 +1,22 @@
+import { error, warn } from '../../utils/logger.js';
+/**
+ * Displays validation issues and returns aggregated error and warning counts.
+ * @param issues - Validation issues to render
+ * @returns Tuple of [errorCount, warningCount]
+ */
+export function displayValidationIssues(issues) {
+    let errors = 0;
+    let warnings = 0;
+    for (const issue of issues) {
+        if (issue.severity === 'error') {
+            error(`${issue.component}: [${issue.check}] ${issue.message}`);
+            errors++;
+        }
+        else {
+            warn(`${issue.component}: [${issue.check}] ${issue.message}`);
+            warnings++;
+        }
+    }
+    return [errors, warnings];
+}
+//# sourceMappingURL=validation-output.js.map

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

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

package/dist/src/commands/import.js

@@ -0,0 +1,241 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { join } from 'node:path';
+import { confirm } from '@clack/prompts';
+import { getProjectPaths, loadConfig, loadState, saveState } from '../core/config.js';
+import { getHead } from '../core/git.js';
+import { getDirtyFiles } from '../core/git-status.js';
+import { applyPatchesWithContinue, computePatchedContent, countPatches, discoverPatches, extractAffectedFiles, PatchError, } from '../core/patch-apply.js';
+import { checkVersionCompatibility, loadPatchesManifest, validatePatchesManifestConsistency, validatePatchIntegrity, } from '../core/patch-manifest.js';
+import { GeneralError } from '../errors/base.js';
+import { toError } from '../utils/errors.js';
+import { pathExists, readText } from '../utils/fs.js';
+import { error, info, intro, isCancel, outro, spinner, success, verbose, warn, } from '../utils/logger.js';
+import { pickDefined } from '../utils/options.js';
+async function getUnmanagedDirtyFiles(engineDir, patchesDir, dirtyFiles) {
+    const classifications = await Promise.all(dirtyFiles.map(async (file) => {
+        try {
+            const [expected, exists] = await Promise.all([
+                computePatchedContent(patchesDir, engineDir, file),
+                pathExists(join(engineDir, file)),
+            ]);
+            const actual = exists ? await readText(join(engineDir, file)) : null;
+            return actual === expected ? null : file;
+        }
+        catch (error) {
+            verbose(`Treating ${file} as unmanaged because patched-content classification failed: ${toError(error).message}`);
+            return file;
+        }
+    }));
+    return classifications.filter((file) => file !== null).sort();
+}
+function reportForcedOverwriteRisk(unmanagedDirtyFiles) {
+    warn(`--force will overwrite ${unmanagedDirtyFiles.length} unmanaged change${unmanagedDirtyFiles.length === 1 ? '' : 's'} in patch-touched file${unmanagedDirtyFiles.length === 1 ? '' : 's'}:`);
+    for (const file of unmanagedDirtyFiles) {
+        warn(`  ${file}`);
+    }
+    warn('Patch reapplication may restore these paths to the engine baseline before reapplying patches.');
+}
+async function checkUncommittedPatchFiles(engineDir, patchesDir, forceImport) {
+    const patches = await discoverPatches(patchesDir);
+    const allTouchedFiles = new Set();
+    for (const patch of patches) {
+        const content = await readText(patch.path);
+        for (const file of extractAffectedFiles(content)) {
+            allTouchedFiles.add(file);
+        }
+    }
+    if (allTouchedFiles.size > 0) {
+        const dirtyFiles = await getDirtyFiles(engineDir, [...allTouchedFiles]);
+        if (dirtyFiles.length > 0) {
+            const unmanagedDirtyFiles = await getUnmanagedDirtyFiles(engineDir, patchesDir, dirtyFiles);
+            if (unmanagedDirtyFiles.length === 0) {
+                info('Patch-backed materialized files already match the stored patch stack.');
+            }
+            else if (!forceImport) {
+                warn('Uncommitted changes detected in files that patches will modify:');
+                for (const file of unmanagedDirtyFiles) {
+                    warn(`  ${file}`);
+                }
+                throw new GeneralError('Uncommitted changes in patch-touched files. Commit or stash them first, or use --force.');
+            }
+            else {
+                reportForcedOverwriteRisk(unmanagedDirtyFiles);
+            }
+        }
+    }
+}
+async function handlePatchFailures(summary, state, projectRoot) {
+    const firstFailed = summary.failed[0];
+    if (firstFailed) {
+        state.pendingResolution = {
+            patchFilename: firstFailed.patch.filename,
+            originalError: firstFailed.error ?? 'Unknown error',
+        };
+        await saveState(projectRoot, state);
+    }
+    for (const result of summary.failed) {
+        error(`\nFailed: ${result.patch.filename}`);
+        if (result.error) {
+            error(`  Error: ${result.error}`);
+        }
+        if (result.conflictingFiles && result.conflictingFiles.length > 0) {
+            error(`  Conflicting files:`);
+            for (const file of result.conflictingFiles) {
+                error(`    - ${file}`);
+            }
+        }
+    }
+    if (summary.failed.length > 1) {
+        info(`\nNote: "fireforge resolve" will address the first failed patch (${firstFailed?.patch.filename}).`);
+        info('Re-run "fireforge import" after resolving to continue with remaining patches.');
+    }
+    if (summary.skipped.length > 0) {
+        warn(`\n${summary.skipped.length} patch(es) were skipped:`);
+        for (const patch of summary.skipped) {
+            warn(`  - ${patch.filename}`);
+        }
+        info('\nUse --continue flag to attempt all patches');
+    }
+    info('\nResolution Instructions:');
+    if (firstFailed) {
+        info(`  Patch ${firstFailed.patch.filename} failed to apply automatically.`);
+    }
+    info('  1. Manually fix the conflicts in the engine/ directory (look for .rej files if any).');
+    info('  2. Run "fireforge resolve" to update the patch file with your manual fixes and continue.');
+    throw new PatchError(`Failed to apply ${summary.failed.length} patch(es)`, firstFailed?.patch.filename);
+}
+async function checkEngineDrift(engineDir, baseCommit, forceImport) {
+    const currentHead = await getHead(engineDir);
+    if (currentHead === baseCommit)
+        return true;
+    if (!process.stdin.isTTY) {
+        if (!forceImport) {
+            throw new GeneralError('Engine HEAD has drifted from base commit. Re-run with --force to bypass drift check.');
+        }
+        warn('Engine HEAD has drifted from base commit. Continuing because --force was provided in non-interactive mode.');
+    }
+    else {
+        if (forceImport) {
+            warn('Engine HEAD has drifted from base commit. Continuing because --force was provided.');
+        }
+        else {
+            warn('Warning: Engine is not at the baseline commit.');
+            const shouldContinue = await confirm({
+                message: 'Engine HEAD has drifted. Applying patches now might lead to unexpected conflicts. Continue anyway?',
+                initialValue: false,
+            });
+            if (isCancel(shouldContinue) || !shouldContinue) {
+                outro('Import cancelled by user');
+                return false;
+            }
+        }
+    }
+    return true;
+}
+/**
+ * Runs the import command to apply patches.
+ * @param projectRoot - Root directory of the project
+ * @param options - Import options
+ */
+export async function importCommand(projectRoot, options = {}) {
+    intro('FireForge Import');
+    const continueOnFailure = options.continue ?? false;
+    const forceImport = options.force ?? false;
+    const paths = getProjectPaths(projectRoot);
+    // Check if engine exists
+    if (!(await pathExists(paths.engine))) {
+        throw new GeneralError('Firefox source not found. Run "fireforge download" first.');
+    }
+    // Engine consistency check before applying patches
+    const state = await loadState(projectRoot);
+    if (state.baseCommit) {
+        const shouldContinue = await checkEngineDrift(paths.engine, state.baseCommit, forceImport);
+        if (!shouldContinue)
+            return;
+    }
+    // Check if patches directory exists
+    if (!(await pathExists(paths.patches))) {
+        info('No patches directory found. Nothing to import.');
+        outro('Import complete (no patches)');
+        return;
+    }
+    // Count patches
+    const patchCount = await countPatches(paths.patches);
+    if (patchCount === 0) {
+        info('No patch files found in patches/ directory.');
+        outro('Import complete (no patches)');
+        return;
+    }
+    info(`Found ${patchCount} patch${patchCount === 1 ? '' : 'es'} to apply`);
+    const manifestConsistencyIssues = await validatePatchesManifestConsistency(paths.patches);
+    if (manifestConsistencyIssues.length > 0) {
+        const issueSummary = manifestConsistencyIssues.map((issue) => issue.message).join('\n  ');
+        throw new GeneralError('Patch manifest consistency check failed. Repair patches/patches.json before importing.\n' +
+            `  ${issueSummary}\n\n` +
+            'Run "fireforge doctor --repair-patches-manifest" to rebuild the manifest from on-disk patch files.');
+    }
+    // Load manifest and check version compatibility
+    const manifest = await loadPatchesManifest(paths.patches);
+    if (manifest) {
+        const config = await loadConfig(projectRoot);
+        const currentVersion = config.firefox.version;
+        for (const patch of manifest.patches) {
+            const warning = checkVersionCompatibility(patch.sourceEsrVersion, currentVersion);
+            if (warning) {
+                warn(`${patch.filename}: ${warning}`);
+            }
+        }
+    }
+    // Validate patch integrity (detect orphaned modification patches)
+    const integrityIssues = await validatePatchIntegrity(paths.patches, paths.engine);
+    if (integrityIssues.length > 0) {
+        warn('\nPatch integrity issues detected:');
+        for (const issue of integrityIssues) {
+            warn(`  ${issue.filename}: ${issue.message}`);
+        }
+        info('Run "fireforge doctor" for more details.\n');
+    }
+    await checkUncommittedPatchFiles(paths.engine, paths.patches, forceImport);
+    const s = spinner('Applying patches...');
+    try {
+        const summary = await applyPatchesWithContinue(paths.patches, paths.engine, continueOnFailure);
+        // Handle failures
+        if (summary.failed.length > 0) {
+            s.error(`${summary.failed.length} patch(es) failed`);
+            await handlePatchFailures(summary, state, projectRoot);
+        }
+        // Count auto-resolved patches
+        const autoResolved = summary.succeeded.filter((r) => r.autoResolved);
+        const autoResolvedCount = autoResolved.length;
+        // Build success message
+        let stopMessage = `Applied ${summary.succeeded.length} patch${summary.succeeded.length === 1 ? '' : 'es'}`;
+        if (autoResolvedCount > 0) {
+            stopMessage += ` (${autoResolvedCount} auto-resolved)`;
+        }
+        s.stop(stopMessage);
+        // List applied patches
+        for (const result of summary.succeeded) {
+            const suffix = result.autoResolved ? ' (auto-resolved)' : '';
+            success(`  ${result.patch.filename}${suffix}`);
+        }
+        outro('All patches applied successfully!');
+    }
+    catch (error) {
+        if (!(error instanceof PatchError)) {
+            s.error('Patch application failed');
+        }
+        throw error;
+    }
+}
+/** Registers the import command on the CLI program. */
+export function registerImport(program, { getProjectRoot, withErrorHandling }) {
+    program
+        .command('import')
+        .description('Apply patches from the patches directory')
+        .option('--continue', 'Continue applying patches even if one fails')
+        .option('-f, --force', 'Proceed despite engine drift and overwrite unmanaged changes in patch-touched files')
+        .action(withErrorHandling(async (options) => {
+        await importCommand(getProjectRoot(), pickDefined(options));
+    }));
+}
+//# sourceMappingURL=import.js.map

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

@@ -0,0 +1,10 @@
+import { Command } from 'commander';
+import type { CommandContext } from '../types/cli.js';
+/**
+ * Runs the lint command to check engine changes against patch quality rules.
+ * @param projectRoot - Root directory of the project
+ * @param files - Optional file/directory paths to lint (relative to engine/)
+ */
+export declare function lintCommand(projectRoot: string, files: string[]): Promise<void>;
+/** Registers the lint command on the CLI program. */
+export declare function registerLint(program: Command, { getProjectRoot, withErrorHandling }: CommandContext): void;

package/dist/src/commands/lint.js

@@ -0,0 +1,118 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { getProjectPaths, loadConfig } from '../core/config.js';
+import { getStatusWithCodes, hasChanges, isGitRepository } from '../core/git.js';
+import { getAllDiff, getDiffForFilesAgainstHead } from '../core/git-diff.js';
+import { getModifiedFilesInDir, getUntrackedFiles, getUntrackedFilesInDir, } from '../core/git-status.js';
+import { extractAffectedFiles } from '../core/patch-apply.js';
+import { lintExportedPatch } from '../core/patch-lint.js';
+import { GeneralError } from '../errors/base.js';
+import { pathExists } from '../utils/fs.js';
+import { info, intro, outro, success, warn } from '../utils/logger.js';
+/**
+ * Runs the lint command to check engine changes against patch quality rules.
+ * @param projectRoot - Root directory of the project
+ * @param files - Optional file/directory paths to lint (relative to engine/)
+ */
+export async function lintCommand(projectRoot, files) {
+    intro('FireForge Lint');
+    const paths = getProjectPaths(projectRoot);
+    if (!(await pathExists(paths.engine))) {
+        throw new GeneralError('Firefox source not found. Run "fireforge download" first.');
+    }
+    if (!(await isGitRepository(paths.engine))) {
+        throw new GeneralError('Engine directory is not a git repository. Run "fireforge download" to initialize.');
+    }
+    let diff;
+    if (files.length > 0) {
+        // Collect specific files/directories
+        const collectedFiles = new Set();
+        let fileStatuses;
+        let untrackedFiles;
+        for (const inputPath of files) {
+            const fullInputPath = join(paths.engine, inputPath);
+            let isDirectory = false;
+            try {
+                const fileStat = await stat(fullInputPath);
+                isDirectory = fileStat.isDirectory();
+            }
+            catch {
+                // Treat as file
+            }
+            if (isDirectory) {
+                const dirPath = inputPath.endsWith('/') ? inputPath.slice(0, -1) : inputPath;
+                const modifiedFiles = await getModifiedFilesInDir(paths.engine, dirPath);
+                const dirUntrackedFiles = await getUntrackedFilesInDir(paths.engine, dirPath);
+                for (const f of modifiedFiles)
+                    collectedFiles.add(f);
+                for (const f of dirUntrackedFiles)
+                    collectedFiles.add(f);
+            }
+            else {
+                if (!fileStatuses) {
+                    fileStatuses = await getStatusWithCodes(paths.engine);
+                }
+                if (!untrackedFiles) {
+                    untrackedFiles = await getUntrackedFiles(paths.engine);
+                }
+                const hasStatus = fileStatuses.some((s) => s.file === inputPath) || untrackedFiles.includes(inputPath);
+                if (hasStatus) {
+                    collectedFiles.add(inputPath);
+                }
+            }
+        }
+        if (collectedFiles.size === 0) {
+            info('No modified files found in the specified paths.');
+            outro('Nothing to lint');
+            return;
+        }
+        diff = await getDiffForFilesAgainstHead(paths.engine, [...collectedFiles].sort());
+    }
+    else {
+        // Lint all changes
+        if (!(await hasChanges(paths.engine))) {
+            info('No changes to lint.');
+            outro('Nothing to lint');
+            return;
+        }
+        diff = await getAllDiff(paths.engine);
+    }
+    if (!diff.trim()) {
+        info('No diff content to lint.');
+        outro('Nothing to lint');
+        return;
+    }
+    const config = await loadConfig(projectRoot);
+    const filesAffected = extractAffectedFiles(diff);
+    const issues = await lintExportedPatch(paths.engine, filesAffected, diff, config);
+    if (issues.length === 0) {
+        success('No lint issues found.');
+        outro('Lint passed');
+        return;
+    }
+    const errors = issues.filter((i) => i.severity === 'error');
+    const warnings = issues.filter((i) => i.severity === 'warning');
+    for (const issue of warnings) {
+        warn(`[${issue.check}] ${issue.file}: ${issue.message}`);
+    }
+    for (const issue of errors) {
+        warn(`ERROR [${issue.check}] ${issue.file}: ${issue.message}`);
+    }
+    info(`\nLint: ${errors.length} error(s), ${warnings.length} warning(s)`);
+    if (errors.length > 0) {
+        outro('Lint failed');
+        throw new GeneralError(`Patch lint found ${errors.length} error(s). Fix these before exporting.`);
+    }
+    outro('Lint passed with warnings');
+}
+/** Registers the lint command on the CLI program. */
+export function registerLint(program, { getProjectRoot, withErrorHandling }) {
+    program
+        .command('lint [paths...]')
+        .description('Lint engine changes against patch quality rules')
+        .action(withErrorHandling(async (paths) => {
+        await lintCommand(getProjectRoot(), paths);
+    }));
+}
+//# sourceMappingURL=lint.js.map

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

@@ -0,0 +1,11 @@
+import { Command } from 'commander';
+import type { CommandContext } from '../types/cli.js';
+import type { PackageOptions } from '../types/commands/index.js';
+/**
+ * Runs the package command to create a distribution package.
+ * @param projectRoot - Root directory of the project
+ * @param options - Package options
+ */
+export declare function packageCommand(projectRoot: string, options: PackageOptions): Promise<void>;
+/** Registers the package command on the CLI program. */
+export declare function registerPackage(program: Command, { getProjectRoot, withErrorHandling }: CommandContext): void;