@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/commands/token-coverage.js

@@ -1,170 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { join } from 'node:path';
-import { getProjectPaths, loadConfig } from '../core/config.js';
-import { assertEngineGitReady } from '../core/engine-precondition.js';
-import { furnaceConfigExists, loadFurnaceConfig } from '../core/furnace-config.js';
-import { expandUntrackedDirectoryEntries, getWorkingTreeStatus } from '../core/git-status.js';
-import { measureTokenCoverage } from '../core/token-coverage.js';
-import { getTokensCssPath } from '../core/token-manager.js';
-import { toError } from '../utils/errors.js';
-import { pathExists, readText } from '../utils/fs.js';
-import { info, intro, outro, success, warn } from '../utils/logger.js';
-/**
- * Measures design token coverage across modified CSS files.
- * @param projectRoot - Root directory of the project
- */
-export async function tokenCoverageCommand(projectRoot) {
-    intro('Token Coverage');
-    const paths = getProjectPaths(projectRoot);
-    await assertEngineGitReady(paths.engine);
-    const config = await loadConfig(projectRoot);
-    const tokensCssPath = getTokensCssPath(config.binaryName);
-    // Expand collapsed `?? dir/` untracked entries so untracked CSS files
-    // inside a new patch-added directory are included in coverage. Before
-    // this, an imported fork that added a new CSS tree saw "No modified
-    // CSS files" because `git status --porcelain` collapsed the directory
-    // and the file-extension filter could not see the .css inside.
-    const rawStatus = await getWorkingTreeStatus(paths.engine);
-    const expandedStatus = await expandUntrackedDirectoryEntries(paths.engine, rawStatus);
-    const statusTokenCssFiles = expandedStatus
-        .filter((f) => f.file === tokensCssPath)
-        .map((f) => f.file);
-    const statusCssFiles = expandedStatus
-        .filter((f) => f.file.endsWith('.css') && f.file !== tokensCssPath)
-        .map((f) => f.file);
-    // Also scan CSS files deployed by Furnace custom components. Deployed
-    // files can be committed (and therefore absent from `git status`) while
-    // still being the primary surface where token adoption matters. Looking
-    // only at modified files silently undercounts projects where Furnace
-    // writes many component-CSS files into the engine.
-    const furnaceCssFiles = await collectFurnaceCustomCssFiles(projectRoot, paths.engine, tokensCssPath);
-    // De-dupe so a file that is both a custom deploy target and modified is
-    // scanned exactly once.
-    const cssFiles = [...new Set([...statusCssFiles, ...furnaceCssFiles])];
-    const tokenSourceFiles = [...new Set(statusTokenCssFiles)];
-    if (cssFiles.length === 0 && tokenSourceFiles.length === 0) {
-        info('No modified CSS files');
-        outro('Nothing to measure');
-        return;
-    }
-    const tokenPrefix = await resolveTokenPrefix(projectRoot, config.binaryName);
-    const tokenSourceResults = await validateTokenSourceFiles(paths.engine, tokenSourceFiles, tokenPrefix);
-    for (const result of tokenSourceResults) {
-        const detail = `${result.tokenDeclarations} token declaration${result.tokenDeclarations === 1 ? '' : 's'}`;
-        if (result.unknownDeclarations.length === 0) {
-            success(`${result.file}  token source valid (${detail})`);
-        }
-        else {
-            warn(`${result.file}  token source has ${result.unknownDeclarations.length} declaration${result.unknownDeclarations.length === 1 ? '' : 's'} outside prefix ${tokenPrefix}: ${result.unknownDeclarations.join(', ')}`);
-        }
-    }
-    if (cssFiles.length === 0) {
-        outro(`${tokenSourceResults.length} token source file${tokenSourceResults.length === 1 ? '' : 's'} validated`);
-        return;
-    }
-    const report = await measureTokenCoverage(paths.engine, cssFiles);
-    // Per-file breakdown
-    for (const entry of report.files) {
-        const parts = [
-            `tokens: ${entry.tokenUsages}`,
-            `allowlisted: ${entry.allowlisted}`,
-            `unknown: ${entry.unknownVars}`,
-            `raw colors: ${entry.rawColors}`,
-        ];
-        info(`${entry.file}  ${parts.join(' | ')}`);
-    }
-    // Coverage calculation
-    const denominator = report.tokenUsages + report.unknownVarUsages + report.rawColorCount;
-    const coverage = denominator > 0 ? Math.round((report.tokenUsages / denominator) * 100) : 100;
-    info('');
-    const summary = `Token coverage: ${coverage}% (${report.tokenUsages} tokens / ${denominator} total) — ${report.rawColorCount} raw colors, ${report.unknownVarUsages} unknown vars`;
-    if (coverage === 100 && report.rawColorCount === 0) {
-        success(summary);
-    }
-    else {
-        warn(summary);
-    }
-    outro(`${report.filesScanned} CSS file${report.filesScanned === 1 ? '' : 's'} scanned`);
-}
-async function resolveTokenPrefix(projectRoot, binaryName) {
-    try {
-        const furnaceConfig = await loadFurnaceConfig(projectRoot);
-        if (furnaceConfig.tokenPrefix) {
-            return furnaceConfig.tokenPrefix;
-        }
-    }
-    catch {
-        // Fall through to the convention used by furnace init. A broken
-        // furnace.json is already surfaced by collectFurnaceCustomCssFiles.
-    }
-    return `--${binaryName}-`;
-}
-async function validateTokenSourceFiles(engineDir, tokenSourceFiles, tokenPrefix) {
-    const results = [];
-    for (const file of tokenSourceFiles) {
-        const filePath = join(engineDir, file);
-        if (!(await pathExists(filePath)))
-            continue;
-        const css = (await readText(filePath)).replace(/\/\*[\s\S]*?\*\//g, '');
-        const declarations = new Set();
-        const declarationPattern = /(^|[;{\s])(--[\w-]+)\s*:/g;
-        let match;
-        while ((match = declarationPattern.exec(css)) !== null) {
-            const declaration = match[2];
-            if (declaration)
-                declarations.add(declaration);
-        }
-        const tokenDeclarations = [...declarations].filter((name) => name.startsWith(tokenPrefix));
-        const unknownDeclarations = [...declarations]
-            .filter((name) => !name.startsWith(tokenPrefix))
-            .sort();
-        results.push({
-            file,
-            tokenDeclarations: tokenDeclarations.length,
-            unknownDeclarations,
-        });
-    }
-    return results;
-}
-/**
- * Returns engine-relative `.css` paths deployed by every Furnace custom
- * component registered in `furnace.json`. Only files that actually exist
- * on disk are included. A component whose deploy target is missing (e.g.
- * `furnace apply` has not run yet) is skipped silently so a fresh
- * `furnace init` followed immediately by `token coverage` does not error.
- *
- * Returns an empty array when the project has no furnace.json, no custom
- * components, or when loading the config fails (a warn is emitted in the
- * last case so the user can diagnose a broken furnace.json without losing
- * coverage results on the non-furnace CSS files).
- */
-async function collectFurnaceCustomCssFiles(projectRoot, engineDir, tokensCssPath) {
-    if (!(await furnaceConfigExists(projectRoot))) {
-        return [];
-    }
-    let furnaceConfig;
-    try {
-        furnaceConfig = await loadFurnaceConfig(projectRoot);
-    }
-    catch (error) {
-        warn(`Could not load furnace.json for token coverage — scanning modified files only (${toError(error).message})`);
-        return [];
-    }
-    const results = [];
-    for (const [componentName, customConfig] of Object.entries(furnaceConfig.custom)) {
-        // Upstream Firefox widget layout: every component lives at
-        // `toolkit/content/widgets/<tagName>/` and ships at least
-        // `<tagName>.css`. `targetPath` already resolves to that directory
-        // (the create command writes `toolkit/content/widgets/<name>` into
-        // furnace.json) so we can probe the default layout directly without
-        // walking the whole tree.
-        const candidate = `${customConfig.targetPath}/${componentName}.css`;
-        if (candidate === tokensCssPath)
-            continue;
-        const absolutePath = join(engineDir, candidate);
-        if (await pathExists(absolutePath)) {
-            results.push(candidate);
-        }
-    }
-    return results;
-}

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

@@ -1,14 +0,0 @@
-/** Options accepted by {@link tokenLintCommand}. */
-export interface TokenLintOptions {
-    /** Emit the machine-readable envelope instead of the human report. */
-    json?: boolean;
-}
-/**
- * Runs `token lint`. Exits non-zero (GeneralError) when any finding is
- * reported; with `--json` the report is written first, as `status --check
- * --json` does.
- *
- * @param projectRoot - Root directory of the project
- * @param options - Output-mode options
- */
-export declare function tokenLintCommand(projectRoot: string, options?: TokenLintOptions): Promise<void>;

package/dist/src/commands/token-lint.js

@@ -1,151 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * `fireforge token lint`: themed-block lockstep and undeclared token
- * references (see `core/token-lint.ts` for the rules).
- *
- * Helper module: no registrar, called from `token.ts`.
- */
-import { join } from 'node:path';
-import { getProjectPaths, loadConfig } from '../core/config.js';
-import { furnaceConfigExists, loadFurnaceConfig } from '../core/furnace-config.js';
-import { buildPatchQueueContext } from '../core/patch-lint.js';
-import { buildJarTargetIndex } from '../core/patch-lint-forward-registration-extended.js';
-import { loadPatchesManifest } from '../core/patch-manifest.js';
-import { collectDeclaredTokenNames, lintTokenLockstep, lintUndeclaredTokenReferences, } from '../core/token-lint.js';
-import { getTokensCssPath } from '../core/token-manager.js';
-import { buildSiblingSheetMap } from '../core/token-sibling-sheets.js';
-import { GeneralError } from '../errors/base.js';
-import { toError } from '../utils/errors.js';
-import { pathExists, readText } from '../utils/fs.js';
-import { info, intro, outro, setMachineOutputMode, setStdoutSealed, success, warn, } from '../utils/logger.js';
-import { emitMachineError, MACHINE_OUTPUT_SCHEMA_VERSION } from '../utils/machine-output.js';
-/** Token prefix, exempt names and sibling sheets from furnace.json, with the init default. */
-async function loadTokenSettings(projectRoot, binaryName) {
-    const fallback = { tokenPrefix: `--${binaryName}-`, exempt: new Set() };
-    if (!(await furnaceConfigExists(projectRoot)))
-        return fallback;
-    try {
-        const furnace = await loadFurnaceConfig(projectRoot);
-        return {
-            tokenPrefix: furnace.tokenPrefix ?? fallback.tokenPrefix,
-            exempt: new Set([...(furnace.tokenAllowlist ?? []), ...(furnace.runtimeVariables ?? [])]),
-            siblingSheets: furnace.tokenSiblingSheets,
-        };
-    }
-    catch (error) {
-        warn(`Could not load furnace.json; using the default token prefix (${toError(error).message})`);
-        return fallback;
-    }
-}
-async function collectTokenLint(projectRoot) {
-    const paths = getProjectPaths(projectRoot);
-    const config = await loadConfig(projectRoot);
-    const tokensCssPath = getTokensCssPath(config.binaryName);
-    const tokensFile = join(paths.engine, tokensCssPath);
-    if (!(await pathExists(tokensFile))) {
-        throw new GeneralError(`Token CSS file not found: ${tokensCssPath}. Run "fireforge furnace init" to seed it.`);
-    }
-    const { tokenPrefix, exempt, siblingSheets } = await loadTokenSettings(projectRoot, config.binaryName);
-    const tokensCss = await readText(tokensFile);
-    const lines = tokensCss.split('\n');
-    const declared = collectDeclaredTokenNames(lines);
-    const findings = [
-        ...lintTokenLockstep(lines, tokensCssPath, tokenPrefix),
-        ...lintUndeclaredTokenReferences(tokensCssPath, tokensCss, tokenPrefix, declared, exempt),
-    ];
-    // Every CSS file the patch queue touches: the fork's own stylesheets and
-    // the upstream ones it edits.
-    const manifest = await loadPatchesManifest(paths.patches);
-    const touched = [...new Set((manifest?.patches ?? []).flatMap((patch) => patch.filesAffected))];
-    const cssFiles = touched.filter((file) => file.endsWith('.css') && file !== tokensCssPath).sort();
-    const contents = await readEngineFiles(paths.engine, touched.filter((file) => LINKING_FILE.test(file)));
-    const siblings = buildSiblingSheetMap({
-        documents: contents,
-        jarTargets: buildJarTargetIndex((await buildPatchQueueContext(paths.patches)).entries),
-        sheets: cssFiles,
-        explicit: siblingSheets,
-    });
-    let filesScanned = 1;
-    for (const file of cssFiles) {
-        const css = contents.get(file);
-        if (css === undefined)
-            continue;
-        filesScanned++;
-        findings.push(...lintUndeclaredTokenReferences(file, css, tokenPrefix, await withSiblingDeclarations(paths.engine, declared, siblings.get(file), contents), exempt));
-    }
-    return { tokensCssPath, tokenPrefix, filesScanned, findings };
-}
-/** Files whose content can link a stylesheet: markup, scripts, and sheets (`@import`). */
-const LINKING_FILE = /\.(?:css|xhtml|html|xml|mjs|js)$/;
-/** Reads the engine files that exist, keyed by engine-relative path. */
-async function readEngineFiles(engineDir, files) {
-    const contents = new Map();
-    for (const file of files) {
-        const absolute = join(engineDir, file);
-        if (await pathExists(absolute))
-            contents.set(file, await readText(absolute));
-    }
-    return contents;
-}
-/** The tokens CSS declarations plus every declaration of a sheet's siblings. */
-async function withSiblingDeclarations(engineDir, declared, siblings, contents) {
-    if (siblings === undefined || siblings.size === 0)
-        return declared;
-    const merged = new Set(declared);
-    for (const sibling of siblings) {
-        if (!contents.has(sibling)) {
-            const absolute = join(engineDir, sibling);
-            if (!(await pathExists(absolute)))
-                continue;
-            contents.set(sibling, await readText(absolute));
-        }
-        const css = contents.get(sibling) ?? '';
-        for (const name of collectDeclaredTokenNames(css.split('\n')))
-            merged.add(name);
-    }
-    return merged;
-}
-function failureMessage(count) {
-    return `token lint found ${String(count)} finding(s).`;
-}
-/**
- * Runs `token lint`. Exits non-zero (GeneralError) when any finding is
- * reported; with `--json` the report is written first, as `status --check
- * --json` does.
- *
- * @param projectRoot - Root directory of the project
- * @param options - Output-mode options
- */
-export async function tokenLintCommand(projectRoot, options = {}) {
-    if (options.json === true) {
-        setMachineOutputMode(true);
-        let findings = 0;
-        try {
-            const report = await collectTokenLint(projectRoot);
-            findings = report.findings.length;
-            process.stdout.write(`${JSON.stringify({ schemaVersion: MACHINE_OUTPUT_SCHEMA_VERSION, ...report }, null, 2)}\n`);
-            setStdoutSealed(true);
-        }
-        catch (error) {
-            emitMachineError('token-lint-failed', toError(error).message);
-        }
-        finally {
-            setMachineOutputMode(false);
-        }
-        if (findings > 0)
-            throw new GeneralError(failureMessage(findings));
-        return;
-    }
-    intro('Token Lint');
-    const report = await collectTokenLint(projectRoot);
-    for (const finding of report.findings) {
-        warn(`${finding.file}:${String(finding.line)} [${finding.check}] ${finding.message}`);
-    }
-    info(`${String(report.filesScanned)} CSS file(s) scanned for ${report.tokenPrefix}* tokens`);
-    if (report.findings.length > 0) {
-        outro('Token lint failed');
-        throw new GeneralError(failureMessage(report.findings.length));
-    }
-    success('Themed blocks are in lockstep with the base block; every token reference resolves');
-    outro('Token lint passed');
-}

package/dist/src/commands/token-list.d.ts

@@ -1,26 +0,0 @@
-/** Options accepted by {@link tokenListCommand}. */
-export interface TokenListOptions {
-    /** Restrict the report to one category. */
-    category?: string;
-    /** Emit the machine-readable envelope instead of the human report. */
-    json?: boolean;
-}
-/**
- * Lists the categories declared in the tokens CSS with their token names,
- * in file order.
- *
- * @param projectRoot - Root directory of the project
- * @param options - Filter and output-mode options
- */
-export declare function tokenListCommand(projectRoot: string, options?: TokenListOptions): Promise<void>;
-/**
- * Reports one token: the category that owns it and the value it takes in
- * every block that declares it.
- *
- * @param projectRoot - Root directory of the project
- * @param tokenName - Custom-property name, with or without the leading `--`
- * @param options - Output-mode options
- */
-export declare function tokenShowCommand(projectRoot: string, tokenName: string, options?: {
-    json?: boolean;
-}): Promise<void>;

package/dist/src/commands/token-list.js

@@ -1,153 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * `token list` and `token show`: the read half of design-token management.
- *
- * `token add` requires `--category` and refuses an unknown one, but nothing
- * reported the categories a project has, so naming one meant hand-parsing a
- * neighbouring `= Category =` banner out of the tokens CSS. Both commands
- * read through `token-inventory.ts`, which is built on the same banner and
- * `:root`-bounds primitives `token add` and `token coverage` use, because
- * a second tokens-CSS parser would let the report and the writer disagree about
- * which section a token lives in.
- *
- * Helper module: no registrar, called from `token.ts`.
- */
-import { join } from 'node:path';
-import { getProjectPaths, loadConfig } from '../core/config.js';
-import { collectTokenBlockValues, collectTokenInventory, } from '../core/token-inventory.js';
-import { getTokensCssPath } from '../core/token-manager.js';
-import { GeneralError } from '../errors/base.js';
-import { toError } from '../utils/errors.js';
-import { pathExists, readText } from '../utils/fs.js';
-import { info, intro, outro, setMachineOutputMode, setStdoutSealed } from '../utils/logger.js';
-import { emitMachineError, MACHINE_OUTPUT_SCHEMA_VERSION } from '../utils/machine-output.js';
-/** Reads the project's tokens CSS as lines, refusing when it is absent. */
-async function readTokensCssLines(projectRoot) {
-    const paths = getProjectPaths(projectRoot);
-    const config = await loadConfig(projectRoot);
-    const tokensCssPath = getTokensCssPath(config.binaryName);
-    const filePath = join(paths.engine, tokensCssPath);
-    if (!(await pathExists(filePath))) {
-        throw new GeneralError(`Token CSS file not found: ${tokensCssPath}. Run "fireforge furnace init" to seed it.`);
-    }
-    return { lines: (await readText(filePath)).split('\n'), tokensCssPath };
-}
-/** Applies the `--category` filter, refusing a name the file does not carry. */
-function filterByCategory(groups, category, tokensCssPath) {
-    const matched = groups.filter((group) => group.category === category);
-    if (matched.length > 0)
-        return matched;
-    // Same "name the alternatives" contract `token add` gives for an unknown
-    // category: a filter that silently prints nothing reads as "this
-    // category is empty", which is a different fact.
-    const available = groups
-        .map((group) => group.category)
-        .filter((name) => name !== null);
-    const suffix = available.length > 0
-        ? `Available categories: ${available.map((name) => `"${name}"`).join(', ')}.`
-        : 'The file declares no category banners.';
-    throw new GeneralError(`Category "${category}" not found in ${tokensCssPath}.\n\n${suffix}`);
-}
-/**
- * Lists the categories declared in the tokens CSS with their token names,
- * in file order.
- *
- * @param projectRoot - Root directory of the project
- * @param options - Filter and output-mode options
- */
-export async function tokenListCommand(projectRoot, options = {}) {
-    if (options.json === true) {
-        // stdout belongs exclusively to the payload from here on. A later
-        // diagnostic (including withErrorHandling's) routes to stderr.
-        setMachineOutputMode(true);
-        try {
-            const { lines, tokensCssPath } = await readTokensCssLines(projectRoot);
-            const all = collectTokenInventory(lines);
-            const groups = options.category === undefined
-                ? all
-                : filterByCategory(all, options.category, tokensCssPath);
-            process.stdout.write(`${JSON.stringify({
-                schemaVersion: MACHINE_OUTPUT_SCHEMA_VERSION,
-                tokensCssPath,
-                categories: groups.map((group) => ({
-                    category: group.category,
-                    tokens: group.tokens.map((token) => ({
-                        name: token.name,
-                        line: token.line,
-                        value: token.value,
-                    })),
-                })),
-            }, null, 2)}\n`);
-            setStdoutSealed(true);
-        }
-        catch (error) {
-            emitMachineError('token-list-failed', toError(error).message);
-        }
-        finally {
-            setMachineOutputMode(false);
-        }
-        return;
-    }
-    const { lines, tokensCssPath } = await readTokensCssLines(projectRoot);
-    const all = collectTokenInventory(lines);
-    const groups = options.category === undefined ? all : filterByCategory(all, options.category, tokensCssPath);
-    intro('Design Tokens');
-    info(tokensCssPath);
-    if (groups.length === 0) {
-        outro('No token declarations found in the :root block');
-        return;
-    }
-    let total = 0;
-    for (const group of groups) {
-        info(`  ${group.category ?? '(no category)'} — ${String(group.tokens.length)} token(s)`);
-        for (const token of group.tokens) {
-            info(`    ${token.name}`);
-        }
-        total += group.tokens.length;
-    }
-    outro(`${String(groups.length)} category/categories, ${String(total)} token(s)`);
-}
-/**
- * Reports one token: the category that owns it and the value it takes in
- * every block that declares it.
- *
- * @param projectRoot - Root directory of the project
- * @param tokenName - Custom-property name, with or without the leading `--`
- * @param options - Output-mode options
- */
-export async function tokenShowCommand(projectRoot, tokenName, options = {}) {
-    const emit = async () => {
-        const { lines, tokensCssPath } = await readTokensCssLines(projectRoot);
-        const name = tokenName.startsWith('--') ? tokenName : `--${tokenName}`;
-        const declarations = collectTokenBlockValues(lines, name);
-        if (declarations.length === 0) {
-            throw new GeneralError(`Token "${name}" is not declared in ${tokensCssPath}. ` +
-                'Run "fireforge token list" to see the declared tokens.');
-        }
-        const owning = collectTokenInventory(lines).find((group) => group.tokens.some((token) => token.name === name));
-        return { tokensCssPath, name, category: owning?.category ?? null, declarations };
-    };
-    if (options.json === true) {
-        setMachineOutputMode(true);
-        try {
-            const report = await emit();
-            process.stdout.write(`${JSON.stringify({ schemaVersion: MACHINE_OUTPUT_SCHEMA_VERSION, ...report }, null, 2)}\n`);
-            setStdoutSealed(true);
-        }
-        catch (error) {
-            emitMachineError('token-show-failed', toError(error).message);
-        }
-        finally {
-            setMachineOutputMode(false);
-        }
-        return;
-    }
-    const report = await emit();
-    intro('Design Token');
-    info(`${report.name} — category: ${report.category ?? '(no category)'}`);
-    info(report.tokensCssPath);
-    for (const declaration of report.declarations) {
-        info(`  ${declaration.block}: ${declaration.value}  (line ${String(declaration.line)})`);
-    }
-    outro(`${String(report.declarations.length)} declaration(s)`);
-}

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

@@ -1,14 +0,0 @@
-import { Command } from 'commander';
-import type { CommandContext } from '../types/cli.js';
-import type { TokenAddOptions } from '../types/commands/index.js';
-/**
- * Adds a design token to the CSS file and documentation.
- *
- * @param projectRoot - Root directory of the project
- * @param tokenName - Full token name including prefix
- * @param value - CSS value
- * @param options - Command options
- */
-export declare function tokenAddCommand(projectRoot: string, tokenName: string, value: string, options: TokenAddOptions): Promise<void>;
-/** Registers token management commands on the CLI program. */
-export declare function registerToken(program: Command, { getProjectRoot, withErrorHandling }: CommandContext): void;

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

@@ -1,19 +0,0 @@
-import { Command } from 'commander';
-import type { CommandContext } from '../types/cli.js';
-/** Creates a verification tree under `.fireforge/trees/<name>`. */
-export declare function treeCreateCommand(projectRoot: string, name: string, options?: {
-    forceCopy?: boolean;
-    withObjdir?: boolean;
-    waitLockSeconds?: number | undefined;
-}): Promise<void>;
-/** Prints the tree list with staleness against the current primary state. */
-export declare function treeListCommand(projectRoot: string, options?: {
-    json?: boolean;
-}): Promise<void>;
-/** Removes one tree (or all of them with `--all`). */
-export declare function treeRemoveCommand(projectRoot: string, name: string | undefined, options?: {
-    all?: boolean;
-    force?: boolean;
-}): Promise<void>;
-/** Registers the tree command group on the CLI program. */
-export declare function registerTree(program: Command, context: CommandContext): void;