@dynamicworks/br-openspec 1.3.1

package/dist/commands/show.d.ts

@@ -0,0 +1,14 @@
+export declare class ShowCommand {
+    execute(itemName?: string, options?: {
+        json?: boolean;
+        type?: string;
+        noInteractive?: boolean;
+        [k: string]: any;
+    }): Promise<void>;
+    private normalizeType;
+    private runInteractiveByType;
+    private showDirect;
+    private printNonInteractiveHint;
+    private warnIrrelevantFlags;
+}
+//# sourceMappingURL=show.d.ts.map

package/dist/commands/show.js

@@ -0,0 +1,133 @@
+import { isInteractive } from '../utils/interactive.js';
+import { getActiveChangeIds, getSpecIds } from '../utils/item-discovery.js';
+import { ChangeCommand } from './change.js';
+import { SpecCommand } from './spec.js';
+import { nearestMatches } from '../utils/match.js';
+import { SHOW_MESSAGES } from '../messages/index.js';
+const CHANGE_FLAG_KEYS = new Set(['deltasOnly', 'requirementsOnly']);
+const SPEC_FLAG_KEYS = new Set(['requirements', 'scenarios', 'requirement']);
+export class ShowCommand {
+    async execute(itemName, options = {}) {
+        const interactive = isInteractive(options);
+        const typeOverride = this.normalizeType(options.type);
+        if (!itemName) {
+            if (interactive) {
+                const { select } = await import('@inquirer/prompts');
+                const type = await select({
+                    message: SHOW_MESSAGES.whatToShow,
+                    choices: [
+                        { name: SHOW_MESSAGES.optionChange, value: 'change' },
+                        { name: SHOW_MESSAGES.optionSpec, value: 'spec' },
+                    ],
+                });
+                await this.runInteractiveByType(type, options);
+                return;
+            }
+            this.printNonInteractiveHint();
+            process.exitCode = 1;
+            return;
+        }
+        await this.showDirect(itemName, { typeOverride, options });
+    }
+    normalizeType(value) {
+        if (!value)
+            return undefined;
+        const v = value.toLowerCase();
+        if (v === 'change' || v === 'spec')
+            return v;
+        return undefined;
+    }
+    async runInteractiveByType(type, options) {
+        const { select } = await import('@inquirer/prompts');
+        if (type === 'change') {
+            const changes = await getActiveChangeIds();
+            if (changes.length === 0) {
+                console.error(SHOW_MESSAGES.noChangesFound);
+                process.exitCode = 1;
+                return;
+            }
+            const picked = await select({ message: SHOW_MESSAGES.pickChange, choices: changes.map(id => ({ name: id, value: id })) });
+            const cmd = new ChangeCommand();
+            await cmd.show(picked, options);
+            return;
+        }
+        const specs = await getSpecIds();
+        if (specs.length === 0) {
+            console.error(SHOW_MESSAGES.noSpecsFound);
+            process.exitCode = 1;
+            return;
+        }
+        const picked = await select({ message: SHOW_MESSAGES.pickSpec, choices: specs.map(id => ({ name: id, value: id })) });
+        const cmd = new SpecCommand();
+        await cmd.show(picked, options);
+    }
+    async showDirect(itemName, params) {
+        // Optimize lookups when type is pre-specified
+        let isChange = false;
+        let isSpec = false;
+        let changes = [];
+        let specs = [];
+        if (params.typeOverride === 'change') {
+            changes = await getActiveChangeIds();
+            isChange = changes.includes(itemName);
+        }
+        else if (params.typeOverride === 'spec') {
+            specs = await getSpecIds();
+            isSpec = specs.includes(itemName);
+        }
+        else {
+            [changes, specs] = await Promise.all([getActiveChangeIds(), getSpecIds()]);
+            isChange = changes.includes(itemName);
+            isSpec = specs.includes(itemName);
+        }
+        const resolvedType = params.typeOverride ?? (isChange ? 'change' : isSpec ? 'spec' : undefined);
+        if (!resolvedType) {
+            console.error(SHOW_MESSAGES.unknownItem(itemName));
+            const suggestions = nearestMatches(itemName, [...changes, ...specs]);
+            if (suggestions.length)
+                console.error(SHOW_MESSAGES.didYouMean(suggestions.join(', ')));
+            process.exitCode = 1;
+            return;
+        }
+        if (!params.typeOverride && isChange && isSpec) {
+            console.error(SHOW_MESSAGES.ambiguousItem(itemName));
+            console.error(SHOW_MESSAGES.passTypeHint);
+            process.exitCode = 1;
+            return;
+        }
+        this.warnIrrelevantFlags(resolvedType, params.options);
+        if (resolvedType === 'change') {
+            const cmd = new ChangeCommand();
+            await cmd.show(itemName, params.options);
+            return;
+        }
+        const cmd = new SpecCommand();
+        await cmd.show(itemName, params.options);
+    }
+    printNonInteractiveHint() {
+        console.error(SHOW_MESSAGES.nothingToShow);
+        console.error(SHOW_MESSAGES.showItemHint);
+        console.error(SHOW_MESSAGES.showChangeHint);
+        console.error(SHOW_MESSAGES.showSpecHint);
+        console.error(SHOW_MESSAGES.runInteractiveHint);
+    }
+    warnIrrelevantFlags(type, options) {
+        const irrelevant = [];
+        if (type === 'change') {
+            for (const k of SPEC_FLAG_KEYS)
+                if (k in options)
+                    irrelevant.push(k);
+        }
+        else {
+            for (const k of CHANGE_FLAG_KEYS)
+                if (k in options)
+                    irrelevant.push(k);
+        }
+        if (irrelevant.length > 0) {
+            console.error(SHOW_MESSAGES.ignoringFlags(type, irrelevant.join(', ')));
+            return true;
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=show.js.map

package/dist/commands/spec.d.ts

@@ -0,0 +1,15 @@
+import { program } from 'commander';
+interface ShowOptions {
+    json?: boolean;
+    requirements?: boolean;
+    scenarios?: boolean;
+    requirement?: string;
+    noInteractive?: boolean;
+}
+export declare class SpecCommand {
+    private SPECS_DIR;
+    show(specId?: string, options?: ShowOptions): Promise<void>;
+}
+export declare function registerSpecCommand(rootProgram: typeof program): import("commander").Command;
+export {};
+//# sourceMappingURL=spec.d.ts.map

package/dist/commands/spec.js

@@ -0,0 +1,226 @@
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { MarkdownParser } from '../core/parsers/markdown-parser.js';
+import { Validator } from '../core/validation/validator.js';
+import { isInteractive } from '../utils/interactive.js';
+import { getSpecIds } from '../utils/item-discovery.js';
+import { CLI_DESCRIPTIONS, CLI_MESSAGES, SPEC_MESSAGES } from '../messages/index.js';
+const SPECS_DIR = 'openspec/specs';
+function parseSpecFromFile(specPath, specId) {
+    const content = readFileSync(specPath, 'utf-8');
+    const parser = new MarkdownParser(content);
+    return parser.parseSpec(specId);
+}
+function validateRequirementIndex(spec, requirementOpt) {
+    if (!requirementOpt)
+        return undefined;
+    const index = Number.parseInt(requirementOpt, 10);
+    if (!Number.isInteger(index) || index < 1 || index > spec.requirements.length) {
+        throw new Error(SPEC_MESSAGES.requirementNotFound(requirementOpt));
+    }
+    return index - 1; // convert to 0-based
+}
+function filterSpec(spec, options) {
+    const requirementIndex = validateRequirementIndex(spec, options.requirement);
+    const includeScenarios = options.scenarios !== false && !options.requirements;
+    const filteredRequirements = (requirementIndex !== undefined
+        ? [spec.requirements[requirementIndex]]
+        : spec.requirements).map(req => ({
+        text: req.text,
+        scenarios: includeScenarios ? req.scenarios : [],
+    }));
+    const metadata = spec.metadata ?? { version: '1.0.0', format: 'openspec' };
+    return {
+        name: spec.name,
+        overview: spec.overview,
+        requirements: filteredRequirements,
+        metadata,
+    };
+}
+/**
+ * Print the raw markdown content for a spec file without any formatting.
+ * Raw-first behavior ensures text mode is a passthrough for deterministic output.
+ */
+function printSpecTextRaw(specPath) {
+    const content = readFileSync(specPath, 'utf-8');
+    console.log(content);
+}
+export class SpecCommand {
+    SPECS_DIR = 'openspec/specs';
+    async show(specId, options = {}) {
+        if (!specId) {
+            const canPrompt = isInteractive(options);
+            const specIds = await getSpecIds();
+            if (canPrompt && specIds.length > 0) {
+                const { select } = await import('@inquirer/prompts');
+                specId = await select({
+                    message: SPEC_MESSAGES.selectSpecToShow,
+                    choices: specIds.map(id => ({ name: id, value: id })),
+                });
+            }
+            else {
+                throw new Error(SPEC_MESSAGES.missingSpecId);
+            }
+        }
+        const specPath = join(this.SPECS_DIR, specId, 'spec.md');
+        if (!existsSync(specPath)) {
+            throw new Error(SPEC_MESSAGES.specNotFound(specId));
+        }
+        if (options.json) {
+            if (options.requirements && options.requirement) {
+                throw new Error(SPEC_MESSAGES.requirementsAndRequirementConflict);
+            }
+            const parsed = parseSpecFromFile(specPath, specId);
+            const filtered = filterSpec(parsed, options);
+            const output = {
+                id: specId,
+                title: parsed.name,
+                overview: parsed.overview,
+                requirementCount: filtered.requirements.length,
+                requirements: filtered.requirements,
+                metadata: parsed.metadata ?? { version: '1.0.0', format: 'openspec' },
+            };
+            console.log(JSON.stringify(output, null, 2));
+            return;
+        }
+        printSpecTextRaw(specPath);
+    }
+}
+export function registerSpecCommand(rootProgram) {
+    const specCommand = rootProgram
+        .command('spec')
+        .description(CLI_DESCRIPTIONS.spec);
+    // Deprecation notice for noun-based commands
+    specCommand.hook('preAction', () => {
+        console.error(CLI_MESSAGES.specCommandsDeprecated);
+    });
+    specCommand
+        .command('show [spec-id]')
+        .description(CLI_DESCRIPTIONS.specShow)
+        .option('--json', CLI_DESCRIPTIONS.specShowJson)
+        .option('--requirements', CLI_DESCRIPTIONS.specShowRequirements)
+        .option('--no-scenarios', CLI_DESCRIPTIONS.specShowNoScenarios)
+        .option('-r, --requirement <id>', CLI_DESCRIPTIONS.specShowRequirement)
+        .option('--no-interactive', CLI_DESCRIPTIONS.specShowNoInteractive)
+        .action(async (specId, options) => {
+        try {
+            const cmd = new SpecCommand();
+            await cmd.show(specId, options);
+        }
+        catch (error) {
+            console.error(CLI_MESSAGES.error(error instanceof Error ? error.message : CLI_MESSAGES.unknownError));
+            process.exitCode = 1;
+        }
+    });
+    specCommand
+        .command('list')
+        .description(CLI_DESCRIPTIONS.specList)
+        .option('--json', CLI_DESCRIPTIONS.specListJson)
+        .option('--long', CLI_DESCRIPTIONS.specListLong)
+        .action((options) => {
+        try {
+            if (!existsSync(SPECS_DIR)) {
+                console.log(SPEC_MESSAGES.noItemsFound);
+                return;
+            }
+            const specs = readdirSync(SPECS_DIR, { withFileTypes: true })
+                .filter(dirent => dirent.isDirectory())
+                .map(dirent => {
+                const specPath = join(SPECS_DIR, dirent.name, 'spec.md');
+                if (existsSync(specPath)) {
+                    try {
+                        const spec = parseSpecFromFile(specPath, dirent.name);
+                        return {
+                            id: dirent.name,
+                            title: spec.name,
+                            requirementCount: spec.requirements.length
+                        };
+                    }
+                    catch {
+                        return {
+                            id: dirent.name,
+                            title: dirent.name,
+                            requirementCount: 0
+                        };
+                    }
+                }
+                return null;
+            })
+                .filter((spec) => spec !== null)
+                .sort((a, b) => a.id.localeCompare(b.id));
+            if (options.json) {
+                console.log(JSON.stringify(specs, null, 2));
+            }
+            else {
+                if (specs.length === 0) {
+                    console.log(SPEC_MESSAGES.noItemsFound);
+                    return;
+                }
+                if (!options.long) {
+                    specs.forEach(spec => console.log(spec.id));
+                    return;
+                }
+                specs.forEach(spec => {
+                    console.log(`${spec.id}: ${spec.title} ${SPEC_MESSAGES.requirementCount(spec.requirementCount)}`);
+                });
+            }
+        }
+        catch (error) {
+            console.error(CLI_MESSAGES.error(error instanceof Error ? error.message : CLI_MESSAGES.unknownError));
+            process.exitCode = 1;
+        }
+    });
+    specCommand
+        .command('validate [spec-id]')
+        .description(CLI_DESCRIPTIONS.specValidate)
+        .option('--strict', CLI_DESCRIPTIONS.specValidateStrict)
+        .option('--json', CLI_DESCRIPTIONS.specValidateJson)
+        .option('--no-interactive', CLI_DESCRIPTIONS.specValidateNoInteractive)
+        .action(async (specId, options) => {
+        try {
+            if (!specId) {
+                const canPrompt = isInteractive(options);
+                const specIds = await getSpecIds();
+                if (canPrompt && specIds.length > 0) {
+                    const { select } = await import('@inquirer/prompts');
+                    specId = await select({
+                        message: SPEC_MESSAGES.selectSpecToValidate,
+                        choices: specIds.map(id => ({ name: id, value: id })),
+                    });
+                }
+                else {
+                    throw new Error(SPEC_MESSAGES.missingSpecId);
+                }
+            }
+            const specPath = join(SPECS_DIR, specId, 'spec.md');
+            if (!existsSync(specPath)) {
+                throw new Error(SPEC_MESSAGES.specNotFound(specId));
+            }
+            const validator = new Validator(options.strict);
+            const report = await validator.validateSpec(specPath);
+            if (options.json) {
+                console.log(JSON.stringify(report, null, 2));
+            }
+            else {
+                if (report.valid) {
+                    console.log(SPEC_MESSAGES.specIsValid(specId));
+                }
+                else {
+                    console.error(SPEC_MESSAGES.specHasIssues(specId));
+                    report.issues.forEach(issue => {
+                        const label = issue.level === 'ERROR' ? 'ERROR' : issue.level;
+                        const prefix = issue.level === 'ERROR' ? '✗' : issue.level === 'WARNING' ? '⚠' : 'ℹ';
+                        console.error(`${prefix} [${label}] ${issue.path}: ${issue.message}`);
+                    });
+                }
+            }
+            process.exitCode = report.valid ? 0 : 1;
+        }
+        catch (error) {
+            console.error(CLI_MESSAGES.error(error instanceof Error ? error.message : CLI_MESSAGES.unknownError));
+            process.exitCode = 1;
+        }
+    });
+    return specCommand;
+}
+//# sourceMappingURL=spec.js.map

package/dist/commands/tools.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Tools Command
+ *
+ * `openspec tools [path]`
+ *
+ * Add or remove IDE/Code Agent BR-OpenSpec configuration files interactively.
+ * Requires the project to already be initialized with `openspec init`.
+ */
+import { Command } from 'commander';
+export declare function registerToolsCommand(program: Command): void;
+//# sourceMappingURL=tools.d.ts.map

package/dist/commands/tools.js

@@ -0,0 +1,252 @@
+/**
+ * Tools Command
+ *
+ * `openspec tools [path]`
+ *
+ * Add or remove IDE/Code Agent BR-OpenSpec configuration files interactively.
+ * Requires the project to already be initialized with `openspec init`.
+ */
+import path from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+import { isProjectInitialized } from '../core/is-project-initialized.js';
+import { addTool, removeTool, getCurrentToolIds, getEligibleTools, resolveToolsArg, } from '../core/tools-manager.js';
+import { AI_TOOLS } from '../core/config.js';
+import { getToolStates } from '../core/shared/index.js';
+import { isInteractive } from '../utils/interactive.js';
+import { TOOLS_MESSAGES, CLI_MESSAGES } from '../messages/index.js';
+// ─────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────────────────
+function requireInitialized(projectPath) {
+    if (!isProjectInitialized(projectPath)) {
+        ora().fail(TOOLS_MESSAGES.notInitialized);
+        process.exit(1);
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Non-interactive add
+// ─────────────────────────────────────────────────────────────────────────────
+async function runAdd(projectPath, toolsArg) {
+    const toolIds = resolveToolsArg(toolsArg);
+    if (toolIds.length === 0) {
+        console.log(chalk.dim(TOOLS_MESSAGES.noToolsToAdd));
+        return;
+    }
+    const added = [];
+    const failed = [];
+    for (const toolId of toolIds) {
+        const tool = AI_TOOLS.find((t) => t.value === toolId);
+        if (!tool)
+            continue;
+        const spinner = ora(TOOLS_MESSAGES.adding(tool.name)).start();
+        try {
+            await addTool(projectPath, tool);
+            spinner.succeed(TOOLS_MESSAGES.added(tool.name));
+            added.push(tool.name);
+        }
+        catch (err) {
+            spinner.fail(TOOLS_MESSAGES.failedToAdd(tool.name));
+            failed.push({ name: tool.name, error: err });
+        }
+    }
+    console.log();
+    if (added.length > 0) {
+        console.log(TOOLS_MESSAGES.addedList(added.join(', ')));
+    }
+    if (failed.length > 0) {
+        console.log(chalk.red(TOOLS_MESSAGES.failedList(failed.map((f) => `${f.name} (${f.error.message})`).join(', '))));
+    }
+    if (added.length > 0) {
+        console.log();
+        console.log(chalk.white(TOOLS_MESSAGES.restartIDE));
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Non-interactive remove
+// ─────────────────────────────────────────────────────────────────────────────
+async function runRemove(projectPath, toolsArg) {
+    const toolIds = resolveToolsArg(toolsArg);
+    if (toolIds.length === 0) {
+        console.log(chalk.dim(TOOLS_MESSAGES.noToolsToRemove));
+        return;
+    }
+    const removed = [];
+    const failed = [];
+    for (const toolId of toolIds) {
+        const tool = AI_TOOLS.find((t) => t.value === toolId);
+        if (!tool)
+            continue;
+        const spinner = ora(TOOLS_MESSAGES.removing(tool.name)).start();
+        try {
+            const counts = await removeTool(projectPath, tool);
+            spinner.succeed(TOOLS_MESSAGES.removed(tool.name));
+            removed.push(tool.name);
+            if (counts.removedSkillCount > 0 || counts.removedCommandCount > 0) {
+                console.log(chalk.dim(TOOLS_MESSAGES.removedCounts(counts.removedSkillCount, counts.removedCommandCount)));
+            }
+        }
+        catch (err) {
+            spinner.fail(TOOLS_MESSAGES.failedToRemove(tool.name));
+            failed.push({ name: tool.name, error: err });
+        }
+    }
+    console.log();
+    if (removed.length > 0) {
+        console.log(TOOLS_MESSAGES.removedList(removed.join(', ')));
+    }
+    if (failed.length > 0) {
+        console.log(chalk.red(TOOLS_MESSAGES.failedList(failed.map((f) => `${f.name} (${f.error.message})`).join(', '))));
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Interactive mode
+// ─────────────────────────────────────────────────────────────────────────────
+async function runInteractive(projectPath) {
+    const eligibleTools = getEligibleTools();
+    const toolStates = getToolStates(projectPath);
+    const currentlyConfigured = getCurrentToolIds(projectPath);
+    // Build choices for the multi-select, sorted: configured first, then the rest
+    const choices = eligibleTools
+        .map((tool) => {
+        const status = toolStates.get(tool.value);
+        const configured = status?.configured ?? false;
+        return {
+            name: tool.name,
+            value: tool.value,
+            configured,
+            preSelected: configured,
+        };
+    })
+        .sort((a, b) => {
+        if (a.configured && !b.configured)
+            return -1;
+        if (!a.configured && b.configured)
+            return 1;
+        return 0;
+    });
+    if (currentlyConfigured.size > 0) {
+        const names = [...currentlyConfigured]
+            .map((id) => AI_TOOLS.find((t) => t.value === id)?.name ?? id)
+            .join(', ');
+        console.log(TOOLS_MESSAGES.currentlyConfigured(names));
+    }
+    else {
+        console.log(chalk.dim(TOOLS_MESSAGES.noToolsConfigured));
+    }
+    console.log();
+    const { searchableMultiSelect } = await import('../prompts/searchable-multi-select.js');
+    const newSelection = await searchableMultiSelect({
+        message: TOOLS_MESSAGES.selectToolsToConfigure(eligibleTools.length),
+        pageSize: 15,
+        choices,
+    });
+    const newSet = new Set(newSelection);
+    // Compute diffs
+    const toAdd = newSelection.filter((id) => !currentlyConfigured.has(id));
+    const toRemove = [...currentlyConfigured].filter((id) => !newSet.has(id));
+    if (toAdd.length === 0 && toRemove.length === 0) {
+        console.log(chalk.dim('\n' + TOOLS_MESSAGES.noChanges));
+        return;
+    }
+    console.log();
+    const addedNames = [];
+    const removedNames = [];
+    const failed = [];
+    for (const toolId of toAdd) {
+        const tool = AI_TOOLS.find((t) => t.value === toolId);
+        if (!tool)
+            continue;
+        const spinner = ora(TOOLS_MESSAGES.adding(tool.name)).start();
+        try {
+            await addTool(projectPath, tool);
+            spinner.succeed(TOOLS_MESSAGES.added(tool.name));
+            addedNames.push(tool.name);
+        }
+        catch (err) {
+            spinner.fail(TOOLS_MESSAGES.failedToAdd(tool.name));
+            failed.push({ name: tool.name, error: err });
+        }
+    }
+    for (const toolId of toRemove) {
+        const tool = AI_TOOLS.find((t) => t.value === toolId);
+        if (!tool)
+            continue;
+        const spinner = ora(TOOLS_MESSAGES.removing(tool.name)).start();
+        try {
+            await removeTool(projectPath, tool);
+            spinner.succeed(TOOLS_MESSAGES.removed(tool.name));
+            removedNames.push(tool.name);
+        }
+        catch (err) {
+            spinner.fail(TOOLS_MESSAGES.failedToRemove(tool.name));
+            failed.push({ name: tool.name, error: err });
+        }
+    }
+    console.log();
+    if (addedNames.length > 0) {
+        console.log(TOOLS_MESSAGES.addedList(addedNames.join(', ')));
+    }
+    if (removedNames.length > 0) {
+        console.log(TOOLS_MESSAGES.removedList(removedNames.join(', ')));
+    }
+    if (failed.length > 0) {
+        console.log(chalk.red(TOOLS_MESSAGES.failedList(failed.map((f) => `${f.name} (${f.error.message})`).join(', '))));
+    }
+    if (addedNames.length > 0) {
+        console.log();
+        console.log(chalk.white(TOOLS_MESSAGES.restartIDE));
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Command registration
+// ─────────────────────────────────────────────────────────────────────────────
+export function registerToolsCommand(program) {
+    program
+        .command('tools [path]')
+        .description(TOOLS_MESSAGES.description)
+        .option('--add <tools>', TOOLS_MESSAGES.addOption)
+        .option('--remove <tools>', TOOLS_MESSAGES.removeOption)
+        .action(async (targetPath = '.', options) => {
+        try {
+            const projectPath = path.resolve(targetPath);
+            requireInitialized(projectPath);
+            const hasAdd = typeof options?.add === 'string';
+            const hasRemove = typeof options?.remove === 'string';
+            if (hasAdd && hasRemove) {
+                // Check for overlap
+                const addIds = resolveToolsArg(options.add);
+                const removeIds = resolveToolsArg(options.remove);
+                const overlap = addIds.filter((id) => removeIds.includes(id));
+                if (overlap.length > 0) {
+                    throw new Error(TOOLS_MESSAGES.cannotAddAndRemoveSame(overlap.join(', ')));
+                }
+                // Run both sequentially
+                if (addIds.length > 0)
+                    await runAdd(projectPath, options.add);
+                if (removeIds.length > 0)
+                    await runRemove(projectPath, options.remove);
+                return;
+            }
+            if (hasAdd) {
+                await runAdd(projectPath, options.add);
+                return;
+            }
+            if (hasRemove) {
+                await runRemove(projectPath, options.remove);
+                return;
+            }
+            // Interactive mode
+            if (!isInteractive()) {
+                throw new Error(TOOLS_MESSAGES.noFlagNonInteractive);
+            }
+            await runInteractive(projectPath);
+        }
+        catch (error) {
+            console.log();
+            ora().fail(CLI_MESSAGES.error(error.message));
+            process.exit(1);
+        }
+    });
+}
+//# sourceMappingURL=tools.js.map

package/dist/commands/validate.d.ts

@@ -0,0 +1,24 @@
+interface ExecuteOptions {
+    all?: boolean;
+    changes?: boolean;
+    specs?: boolean;
+    type?: string;
+    strict?: boolean;
+    json?: boolean;
+    noInteractive?: boolean;
+    interactive?: boolean;
+    concurrency?: string;
+}
+export declare class ValidateCommand {
+    execute(itemName: string | undefined, options?: ExecuteOptions): Promise<void>;
+    private normalizeType;
+    private runInteractiveSelector;
+    private printNonInteractiveHint;
+    private validateDirectItem;
+    private validateByType;
+    private printReport;
+    private printNextSteps;
+    private runBulkValidation;
+}
+export {};
+//# sourceMappingURL=validate.d.ts.map