@hominis/fireforge 0.9.0

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

@@ -0,0 +1,8 @@
+import type { FurnaceOverrideOptions } from '../../types/commands/index.js';
+/**
+ * Runs the furnace override command to fork an existing engine component.
+ * @param projectRoot - Root directory of the project
+ * @param name - Optional component tag name (prompted if not provided)
+ * @param options - CLI options for non-interactive mode
+ */
+export declare function furnaceOverrideCommand(projectRoot: string, name?: string, options?: FurnaceOverrideOptions): Promise<void>;

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

@@ -0,0 +1,188 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { select, text } from '@clack/prompts';
+import { getProjectPaths, loadConfig } from '../../core/config.js';
+import { ensureFurnaceConfig, getFurnacePaths, writeFurnaceConfig, } from '../../core/furnace-config.js';
+import { getComponentDetails, scanWidgetsDirectory } from '../../core/furnace-scanner.js';
+import { InvalidArgumentError } from '../../errors/base.js';
+import { FurnaceError } from '../../errors/furnace.js';
+import { copyFile, ensureDir, pathExists, writeJson } from '../../utils/fs.js';
+import { cancel, intro, isCancel, note, outro } from '../../utils/logger.js';
+/**
+ * Copies the source files needed for a new override into the workspace.
+ * @param srcDir - Original component directory in the engine checkout
+ * @param destDir - Destination override directory in the workspace
+ * @param overrideType - Requested override mode
+ * @returns Filenames copied into the override directory
+ */
+async function copyOverrideFiles(srcDir, destDir, overrideType) {
+    await ensureDir(destDir);
+    const entries = await readdir(srcDir, { withFileTypes: true });
+    const copiedFiles = [];
+    for (const entry of entries) {
+        if (!entry.isFile())
+            continue;
+        if (overrideType === 'css-only') {
+            // Only copy .css files
+            if (entry.name.endsWith('.css')) {
+                await copyFile(join(srcDir, entry.name), join(destDir, entry.name));
+                copiedFiles.push(entry.name);
+            }
+        }
+        else {
+            // Full override: copy .mjs and .css files
+            if (entry.name.endsWith('.mjs') || entry.name.endsWith('.css')) {
+                await copyFile(join(srcDir, entry.name), join(destDir, entry.name));
+                copiedFiles.push(entry.name);
+            }
+        }
+    }
+    return copiedFiles;
+}
+/**
+ * Writes override metadata to disk and updates furnace.json with the new override entry.
+ * @param projectRoot - Root directory of the project
+ * @param destDir - Override component directory
+ * @param componentName - Component tag name
+ * @param overrideType - Override mode that was created
+ * @param description - Human-readable override description
+ * @param details - Source component metadata from the engine scan
+ * @param firefoxVersion - Firefox version recorded in the workspace config
+ * @param config - Mutable Furnace config object to update
+ */
+async function saveOverrideConfig(projectRoot, destDir, componentName, overrideType, description, details, firefoxVersion, config) {
+    const overrideJson = {
+        type: overrideType,
+        description,
+        basePath: details.sourcePath,
+        baseVersion: firefoxVersion,
+    };
+    await writeJson(join(destDir, 'override.json'), overrideJson);
+    config.overrides[componentName] = {
+        type: overrideType,
+        description,
+        basePath: details.sourcePath,
+        baseVersion: firefoxVersion,
+    };
+    await writeFurnaceConfig(projectRoot, config);
+}
+/**
+ * Runs the furnace override command to fork an existing engine component.
+ * @param projectRoot - Root directory of the project
+ * @param name - Optional component tag name (prompted if not provided)
+ * @param options - CLI options for non-interactive mode
+ */
+export async function furnaceOverrideCommand(projectRoot, name, options = {}) {
+    const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
+    intro('Furnace Override');
+    // Load or create furnace.json
+    const config = await ensureFurnaceConfig(projectRoot);
+    const paths = getProjectPaths(projectRoot);
+    const furnacePaths = getFurnacePaths(projectRoot);
+    // Verify engine/ exists
+    if (!(await pathExists(paths.engine))) {
+        throw new FurnaceError('Engine directory not found. Run "fireforge download" first.');
+    }
+    // --- Resolve component name ---
+    let componentName = name;
+    if (!componentName && isInteractive) {
+        // Scan for available components, filtering out already-overridden ones
+        const allComponents = await scanWidgetsDirectory(paths.engine);
+        const available = allComponents.filter((c) => !(c.tagName in config.overrides));
+        if (available.length === 0) {
+            throw new FurnaceError('No components available to override.');
+        }
+        const selected = await select({
+            message: 'Select a component to override:',
+            options: available.map((c) => ({
+                value: c.tagName,
+                label: c.tagName,
+                hint: [c.hasCSS && 'CSS', c.hasFTL && 'FTL', c.isRegistered && 'registered']
+                    .filter(Boolean)
+                    .join(', '),
+            })),
+        });
+        if (isCancel(selected)) {
+            cancel('Override cancelled');
+            return;
+        }
+        componentName = selected;
+    }
+    else if (!componentName) {
+        throw new InvalidArgumentError('Component name is required in non-interactive mode.\n' +
+            'Usage: fireforge furnace override <name> -t <type> -d "description"', 'name');
+    }
+    // Validate component name to prevent path traversal
+    if (!/^[a-z][a-z0-9]*-[a-z0-9-]*$/.test(componentName)) {
+        throw new InvalidArgumentError(`Invalid component name "${componentName}": must contain a hyphen (required for custom elements), with only lowercase letters, digits, and hyphens.`, 'name');
+    }
+    // Check for existing override
+    if (componentName in config.overrides) {
+        throw new FurnaceError(`An override for "${componentName}" already exists in furnace.json`, componentName);
+    }
+    // Validate the component exists in engine
+    const details = await getComponentDetails(paths.engine, componentName);
+    if (!details) {
+        throw new FurnaceError(`Component "${componentName}" not found in the engine source tree.`, componentName);
+    }
+    // --- Resolve override type ---
+    let overrideType = options.type;
+    if (!overrideType && isInteractive) {
+        const typeResult = await select({
+            message: 'Override type:',
+            options: [
+                {
+                    value: 'css-only',
+                    label: 'CSS only — restyle the component',
+                },
+                {
+                    value: 'full',
+                    label: 'Full override — modify styling and behavior',
+                },
+            ],
+        });
+        if (isCancel(typeResult)) {
+            cancel('Override cancelled');
+            return;
+        }
+        overrideType = typeResult;
+    }
+    else if (!overrideType) {
+        throw new InvalidArgumentError('Override type is required in non-interactive mode. Use -t css-only or -t full.', 'type');
+    }
+    if (overrideType === 'css-only' && !details.hasCSS) {
+        throw new FurnaceError(`Component "${componentName}" does not have any CSS files to override with --type css-only.`, componentName);
+    }
+    // --- Resolve description ---
+    let description = options.description ?? '';
+    if (!description && isInteractive) {
+        const descResult = await text({
+            message: 'Description (optional):',
+            placeholder: 'What are you changing about this component?',
+        });
+        if (!isCancel(descResult)) {
+            description = String(descResult);
+        }
+    }
+    // --- Copy original files ---
+    const srcDir = join(paths.engine, details.sourcePath);
+    const destDir = join(furnacePaths.overridesDir, componentName);
+    if (await pathExists(destDir)) {
+        throw new FurnaceError(`Directory already exists: components/overrides/${componentName}`, componentName);
+    }
+    const forgeConfig = await loadConfig(projectRoot);
+    const copiedFiles = await copyOverrideFiles(srcDir, destDir, overrideType);
+    await saveOverrideConfig(projectRoot, destDir, componentName, overrideType, description, details, forgeConfig.firefox.version, config);
+    // --- Success ---
+    note(`Files copied to components/overrides/${componentName}/:\n` +
+        copiedFiles.map((f) => `  ${f}`).join('\n') +
+        '\n  override.json' +
+        '\n\n' +
+        'Next steps:\n' +
+        `  1. Edit the copied files in components/overrides/${componentName}/\n` +
+        '  2. Run "fireforge furnace preview" to see changes\n' +
+        '  3. Run "fireforge build" to apply and build', componentName);
+    outro('Override created');
+}
+//# sourceMappingURL=override.js.map

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

@@ -0,0 +1,7 @@
+import type { FurnacePreviewOptions } from '../../types/commands/index.js';
+/**
+ * Runs the furnace preview command to start Storybook for component preview.
+ * @param projectRoot - Root directory of the project
+ * @param options - Command options
+ */
+export declare function furnacePreviewCommand(projectRoot: string, options?: FurnacePreviewOptions): Promise<void>;

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

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { join } from 'node:path';
+import { getProjectPaths } from '../../core/config.js';
+import { furnaceConfigExists, loadFurnaceConfig } from '../../core/furnace-config.js';
+import { cleanStories, syncStories } from '../../core/furnace-stories.js';
+import { runMach, runMachCapture } from '../../core/mach.js';
+import { FurnaceError } from '../../errors/furnace.js';
+import { pathExists } from '../../utils/fs.js';
+import { info, intro, outro, spinner } from '../../utils/logger.js';
+/**
+ * Builds a targeted Storybook failure message from captured mach output.
+ * @param output - Combined stdout and stderr from the Storybook command
+ * @param installRequested - Whether the caller requested a dependency reinstall first
+ * @returns User-facing guidance for the specific failure mode
+ */
+function buildStorybookFailureMessage(output, installRequested) {
+    const installHint = installRequested
+        ? 'Try running "python3 ./mach storybook upgrade" manually in the engine directory.'
+        : 'Run "fireforge furnace preview --install" to bootstrap Storybook dependencies, or run "python3 ./mach storybook upgrade" manually in engine/.';
+    if (/(ENOENT|No such file or directory)/i.test(output) && /storybook|backend/i.test(output)) {
+        return ('Storybook failed because the Firefox checkout appears to be missing Storybook workspace files or backend dependencies.\n\n' +
+            installHint);
+    }
+    return ('Storybook failed to start. Check the output above for the specific Firefox-side error.\n\n' +
+        installHint);
+}
+/**
+ * Runs the furnace preview command to start Storybook for component preview.
+ * @param projectRoot - Root directory of the project
+ * @param options - Command options
+ */
+export async function furnacePreviewCommand(projectRoot, options = {}) {
+    intro('Furnace Preview (Storybook)');
+    // Verify engine exists
+    const paths = getProjectPaths(projectRoot);
+    if (!(await pathExists(paths.engine))) {
+        throw new FurnaceError('Engine directory not found. Run "fireforge download" first.');
+    }
+    // Load furnace config
+    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 stockCount = config.stock.length;
+    const overrideCount = Object.keys(config.overrides).length;
+    const customCount = Object.keys(config.custom).length;
+    const totalCount = stockCount + overrideCount + customCount;
+    if (totalCount === 0) {
+        info('No components to preview.');
+        outro('Done');
+        return;
+    }
+    const storybookRoot = join(paths.engine, 'browser', 'components', 'storybook');
+    if (!(await pathExists(storybookRoot))) {
+        throw new FurnaceError('This Firefox checkout does not contain browser/components/storybook. Furnace preview requires the upstream Storybook workspace to exist before stories can be synced.');
+    }
+    let previewResult;
+    let storiesSynced = false;
+    try {
+        // Sync story files
+        const syncSpinner = spinner('Syncing component stories...');
+        const result = await syncStories(projectRoot);
+        storiesSynced = true;
+        const created = result.created.length;
+        const updated = result.updated.length;
+        const total = created + updated;
+        syncSpinner.stop(`Synced ${total} stories (${created} new, ${updated} updated)`);
+        // Force-reinstall Storybook dependencies if requested
+        if (options.install) {
+            const installSpinner = spinner('Reinstalling Storybook dependencies...');
+            const installCode = await runMach(['storybook', 'upgrade'], paths.engine);
+            if (installCode !== 0) {
+                installSpinner.stop('Failed to reinstall Storybook dependencies');
+                throw new FurnaceError('Storybook dependency reinstallation failed. Try running "python3 ./mach storybook upgrade" manually in the engine directory.');
+            }
+            installSpinner.stop('Storybook dependencies reinstalled');
+        }
+        // Start Storybook
+        info('Starting Storybook...');
+        info('Press Ctrl+C to stop\n');
+        previewResult = await runMachCapture(['storybook'], paths.engine);
+    }
+    finally {
+        if (storiesSynced) {
+            await cleanStories(paths.engine);
+        }
+    }
+    if (previewResult.exitCode !== 0 &&
+        previewResult.exitCode !== 130 &&
+        previewResult.exitCode !== 143) {
+        const combinedOutput = `${previewResult.stdout}\n${previewResult.stderr}`;
+        throw new FurnaceError(buildStorybookFailureMessage(combinedOutput, options.install ?? false));
+    }
+    outro('Storybook stopped');
+}
+//# sourceMappingURL=preview.js.map

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

@@ -0,0 +1,8 @@
+import type { FurnaceRemoveOptions } from '../../types/commands/index.js';
+/**
+ * Runs the furnace remove command to remove a component from the workspace.
+ * @param projectRoot - Root directory of the project
+ * @param name - Component tag name to remove
+ * @param options - CLI options
+ */
+export declare function furnaceRemoveCommand(projectRoot: string, name: string, options?: FurnaceRemoveOptions): Promise<void>;

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

@@ -0,0 +1,159 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { readdir, unlink } from 'node:fs/promises';
+import { join } from 'node:path';
+import { confirm } from '@clack/prompts';
+import { getProjectPaths, loadConfig } from '../../core/config.js';
+import { getFurnacePaths, loadFurnaceConfig, writeFurnaceConfig, } from '../../core/furnace-config.js';
+import { removeCustomElementRegistration, removeJarMnEntries, } from '../../core/furnace-registration.js';
+import { deregisterTestManifest } from '../../core/manifest-register.js';
+import { FurnaceError } from '../../errors/furnace.js';
+import { toError } from '../../utils/errors.js';
+import { pathExists, readText, removeDir, writeText } from '../../utils/fs.js';
+import { cancel, info, intro, isCancel, outro, warn } from '../../utils/logger.js';
+/**
+ * Finds which section a component belongs to in the furnace config.
+ * @returns The component type, or undefined if not found
+ */
+function findComponentType(config, name) {
+    if (config.stock.includes(name))
+        return 'stock';
+    if (name in config.overrides)
+        return 'override';
+    if (name in config.custom)
+        return 'custom';
+    return undefined;
+}
+/**
+ * Removes generated browser mochitest files associated with a custom component.
+ * @param name - Custom component tag name
+ * @param projectRoot - Root directory of the project
+ */
+async function cleanupCustomTestFiles(name, projectRoot) {
+    try {
+        const forgeConfig = await loadConfig(projectRoot);
+        const paths = getProjectPaths(projectRoot);
+        const binaryName = forgeConfig.binaryName;
+        const strippedName = name.startsWith('moz-') ? name.slice(4) : name;
+        const withoutBinaryPrefix = strippedName.startsWith(binaryName + '-')
+            ? strippedName.slice(binaryName.length + 1)
+            : strippedName;
+        const underscored = withoutBinaryPrefix.replace(/-/g, '_');
+        const testFileName = `browser_${binaryName}_${underscored}.js`;
+        const testDir = join(paths.engine, 'browser/base/content/test', binaryName);
+        if (await pathExists(testDir)) {
+            const testFilePath = join(testDir, testFileName);
+            if (await pathExists(testFilePath)) {
+                await unlink(testFilePath);
+                info(`Deleted test file: ${testFileName}`);
+            }
+            const tomlPath = join(testDir, 'browser.toml');
+            if (await pathExists(tomlPath)) {
+                const toml = await readText(tomlPath);
+                const entryPattern = `["${testFileName}"]`;
+                if (toml.includes(entryPattern)) {
+                    const updated = toml.replace(new RegExp(`\\n?\\n?\\["${testFileName}"\\]\\n?`), '\n');
+                    await writeText(tomlPath, updated);
+                }
+            }
+            const remaining = await readdir(testDir);
+            const hasTests = remaining.some((f) => f.startsWith('browser_') && f.endsWith('.js'));
+            if (!hasTests) {
+                await removeDir(testDir);
+                info(`Deleted empty test directory: browser/base/content/test/${binaryName}/`);
+                if (await deregisterTestManifest(paths.engine, binaryName)) {
+                    info('Deregistered test manifest from browser/base/moz.build');
+                }
+            }
+        }
+    }
+    catch (error) {
+        warn(`Could not clean up test files — ${toError(error).message}. Remove them manually if needed.`);
+    }
+}
+/**
+ * Runs the furnace remove command to remove a component from the workspace.
+ * @param projectRoot - Root directory of the project
+ * @param name - Component tag name to remove
+ * @param options - CLI options
+ */
+export async function furnaceRemoveCommand(projectRoot, name, options = {}) {
+    const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
+    intro('Furnace Remove');
+    const config = await loadFurnaceConfig(projectRoot);
+    const furnacePaths = getFurnacePaths(projectRoot);
+    // Find which section the component belongs to
+    const type = findComponentType(config, name);
+    if (!type) {
+        throw new FurnaceError(`Component "${name}" not found in furnace.json. Run "fireforge furnace list" to see registered components.`, name);
+    }
+    // Require --force in non-interactive mode to prevent silent removals
+    if (!isInteractive && !options.force) {
+        throw new FurnaceError(`Cannot remove "${name}" in non-interactive mode without --force flag.`, name);
+    }
+    // Confirm removal (skip if --force)
+    if (!options.force && isInteractive) {
+        const confirmed = await confirm({
+            message: `Remove ${type} component "${name}"?`,
+        });
+        if (isCancel(confirmed) || !confirmed) {
+            cancel('Remove cancelled');
+            return;
+        }
+    }
+    // Delete component directory for override and custom types
+    const paths = getProjectPaths(projectRoot);
+    if (type === 'override') {
+        const dir = join(furnacePaths.overridesDir, name);
+        if (await pathExists(dir)) {
+            await removeDir(dir);
+            info(`Deleted components/overrides/${name}/`);
+        }
+        // Clean up deployed files in engine
+        const overrideConfig = config.overrides[name];
+        if (overrideConfig?.basePath) {
+            const engineDir = join(paths.engine, overrideConfig.basePath);
+            if (await pathExists(engineDir)) {
+                warn(`Deployed files may remain in engine/${overrideConfig.basePath}. Run "fireforge reset -f && fireforge import" to clean.`);
+            }
+        }
+    }
+    else if (type === 'custom') {
+        const customConfig = config.custom[name];
+        if (customConfig?.register) {
+            await removeCustomElementRegistration(paths.engine, name);
+            info(`Deregistered ${name} from customElements.js`);
+        }
+        await removeJarMnEntries(paths.engine, name);
+        info(`Removed ${name} entries from toolkit/content/jar.mn`);
+        const dir = join(furnacePaths.customDir, name);
+        if (await pathExists(dir)) {
+            await removeDir(dir);
+            info(`Deleted components/custom/${name}/`);
+        }
+        // Clean up deployed files in engine
+        if (customConfig?.targetPath) {
+            const engineDir = join(paths.engine, customConfig.targetPath);
+            if (await pathExists(engineDir)) {
+                await removeDir(engineDir);
+                info(`Deleted deployed files from engine/${customConfig.targetPath}/`);
+            }
+        }
+    }
+    if (type === 'custom') {
+        await cleanupCustomTestFiles(name, projectRoot);
+    }
+    // Remove entry from furnace.json
+    if (type === 'stock') {
+        config.stock = config.stock.filter((s) => s !== name);
+    }
+    else if (type === 'override') {
+        config.overrides = Object.fromEntries(Object.entries(config.overrides).filter(([key]) => key !== name));
+    }
+    else {
+        config.custom = Object.fromEntries(Object.entries(config.custom).filter(([key]) => key !== name));
+    }
+    await writeFurnaceConfig(projectRoot, config);
+    info(`Removed "${name}" from furnace.json`);
+    outro('Component removed');
+}
+//# sourceMappingURL=remove.js.map

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

@@ -0,0 +1,5 @@
+/**
+ * Runs the furnace scan command to discover MozLitElement components.
+ * @param projectRoot - Root directory of the project
+ */
+export declare function furnaceScanCommand(projectRoot: string): Promise<void>;

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

@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { confirm, multiselect } from '@clack/prompts';
+import { getProjectPaths } from '../../core/config.js';
+import { ensureFurnaceConfig, furnaceConfigExists, loadFurnaceConfig, writeFurnaceConfig, } from '../../core/furnace-config.js';
+import { scanWidgetsDirectory } from '../../core/furnace-scanner.js';
+import { FurnaceError } from '../../errors/furnace.js';
+import { pathExists } from '../../utils/fs.js';
+import { cancel, info, intro, isCancel, note, outro, spinner, success, } from '../../utils/logger.js';
+/**
+ * Prompts the user to add newly discovered stock components to furnace.json.
+ * @param components - Components discovered in the engine scan
+ * @param tracked - Existing Furnace tracking map keyed by tag name
+ * @param projectRoot - Root directory of the project
+ */
+async function promptAddComponents(components, tracked, projectRoot) {
+    const untrackedComponents = components.filter((c) => !tracked.has(c.tagName));
+    const shouldAdd = await confirm({ message: 'Add components to furnace.json?' });
+    if (isCancel(shouldAdd) || !shouldAdd) {
+        if (isCancel(shouldAdd)) {
+            cancel('Cancelled');
+        }
+        outro('Scan complete');
+        return;
+    }
+    const selected = await multiselect({
+        message: 'Select components to add as stock',
+        options: untrackedComponents.map((c) => {
+            const features = [];
+            if (c.hasCSS)
+                features.push('CSS');
+            if (c.hasFTL)
+                features.push('FTL');
+            if (c.isRegistered)
+                features.push('registered');
+            const label = features.length > 0 ? `${c.tagName} — ${features.join(', ')}` : c.tagName;
+            return { value: c.tagName, label };
+        }),
+    });
+    if (isCancel(selected)) {
+        cancel('Cancelled');
+        outro('Scan complete');
+        return;
+    }
+    const config = await ensureFurnaceConfig(projectRoot);
+    const toAdd = selected.filter((s) => !config.stock.includes(s));
+    config.stock.push(...toAdd);
+    await writeFurnaceConfig(projectRoot, config);
+    success(`Added ${selected.length} component${selected.length === 1 ? '' : 's'} to furnace.json`);
+}
+/**
+ * Runs the furnace scan command to discover MozLitElement components.
+ * @param projectRoot - Root directory of the project
+ */
+export async function furnaceScanCommand(projectRoot) {
+    intro('Furnace Scan');
+    const paths = getProjectPaths(projectRoot);
+    if (!(await pathExists(paths.engine))) {
+        throw new FurnaceError('Engine directory not found. Run "fireforge download" first.');
+    }
+    const s = spinner('Scanning engine for components...');
+    const components = await scanWidgetsDirectory(paths.engine);
+    s.stop(`Found ${components.length} component${components.length === 1 ? '' : 's'}`);
+    // Build tracking info from furnace.json if it exists
+    const tracked = new Map();
+    if (await furnaceConfigExists(projectRoot)) {
+        const config = await loadFurnaceConfig(projectRoot);
+        for (const name of config.stock) {
+            tracked.set(name, 'stock');
+        }
+        for (const name of Object.keys(config.overrides)) {
+            tracked.set(name, 'override');
+        }
+        for (const name of Object.keys(config.custom)) {
+            tracked.set(name, 'custom');
+        }
+    }
+    // Display each component
+    for (const component of components) {
+        const features = [];
+        if (component.hasCSS)
+            features.push('CSS');
+        if (component.hasFTL)
+            features.push('FTL');
+        if (component.isRegistered)
+            features.push('registered');
+        let line = component.tagName;
+        if (features.length > 0) {
+            line += ` — ${features.join(', ')}`;
+        }
+        const type = tracked.get(component.tagName);
+        if (type) {
+            line += ` [${type}]`;
+        }
+        info(line);
+    }
+    // Summary
+    let trackedCount = 0;
+    for (const component of components) {
+        if (tracked.has(component.tagName)) {
+            trackedCount++;
+        }
+    }
+    const untrackedCount = components.length - trackedCount;
+    note(`Total: ${components.length}  Tracked: ${trackedCount}  Untracked: ${untrackedCount}`, 'Summary');
+    const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
+    if (isInteractive && untrackedCount > 0) {
+        await promptAddComponents(components, tracked, projectRoot);
+        return;
+    }
+    outro('Scan complete');
+}
+//# sourceMappingURL=scan.js.map

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

@@ -0,0 +1,7 @@
+/**
+ * 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 declare function furnaceStatusCommand(projectRoot: string, name?: string): Promise<void>;