@fission-ai/openspec 0.23.0 → 1.0.0

package/dist/core/update.d.ts

@@ -1,4 +1,42 @@
+/**
+ * Update Command
+ *
+ * Refreshes OpenSpec skills and commands for configured tools.
+ * Supports smart update detection to skip updates when already current.
+ */
+/**
+ * Options for the update command.
+ */
+export interface UpdateCommandOptions {
+    /** Force update even when tools are up to date */
+    force?: boolean;
+}
 export declare class UpdateCommand {
+    private readonly force;
+    constructor(options?: UpdateCommandOptions);
     execute(projectPath: string): Promise<void>;
+    /**
+     * Display message when all tools are up to date.
+     */
+    private displayUpToDateMessage;
+    /**
+     * Display the update plan showing which tools need updating.
+     */
+    private displayUpdatePlan;
+    /**
+     * Detect and handle legacy OpenSpec artifacts.
+     * Unlike init, update warns but continues if legacy files found in non-interactive mode.
+     * Returns array of tool IDs that were newly configured during legacy upgrade.
+     */
+    private handleLegacyCleanup;
+    /**
+     * Perform cleanup of legacy artifacts.
+     */
+    private performLegacyCleanup;
+    /**
+     * Upgrade legacy tools to new skills system.
+     * Returns array of tool IDs that were newly configured.
+     */
+    private upgradeLegacyTools;
 }
 //# sourceMappingURL=update.d.ts.map

package/dist/core/update.js

@@ -1,88 +1,306 @@
+/**
+ * Update Command
+ *
+ * Refreshes OpenSpec skills and commands for configured tools.
+ * Supports smart update detection to skip updates when already current.
+ */
 import path from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+import { createRequire } from 'module';
 import { FileSystemUtils } from '../utils/file-system.js';
-import { OPENSPEC_DIR_NAME } from './config.js';
-import { ToolRegistry } from './configurators/registry.js';
-import { SlashCommandRegistry } from './configurators/slash/registry.js';
-import { agentsTemplate } from './templates/agents-template.js';
+import { AI_TOOLS, OPENSPEC_DIR_NAME } from './config.js';
+import { generateCommands, CommandAdapterRegistry, } from './command-generation/index.js';
+import { getConfiguredTools, getAllToolVersionStatus, getSkillTemplates, getCommandContents, generateSkillContent, getToolsWithSkillsDir, } from './shared/index.js';
+import { detectLegacyArtifacts, cleanupLegacyArtifacts, formatCleanupSummary, formatDetectionSummary, getToolsFromLegacyArtifacts, } from './legacy-cleanup.js';
+import { isInteractive } from '../utils/interactive.js';
+const require = createRequire(import.meta.url);
+const { version: OPENSPEC_VERSION } = require('../../package.json');
 export class UpdateCommand {
+    force;
+    constructor(options = {}) {
+        this.force = options.force ?? false;
+    }
     async execute(projectPath) {
         const resolvedProjectPath = path.resolve(projectPath);
-        const openspecDirName = OPENSPEC_DIR_NAME;
-        const openspecPath = path.join(resolvedProjectPath, openspecDirName);
+        const openspecPath = path.join(resolvedProjectPath, OPENSPEC_DIR_NAME);
         // 1. Check openspec directory exists
         if (!await FileSystemUtils.directoryExists(openspecPath)) {
             throw new Error(`No OpenSpec directory found. Run 'openspec init' first.`);
         }
-        // 2. Update AGENTS.md (full replacement)
-        const agentsPath = path.join(openspecPath, 'AGENTS.md');
-        await FileSystemUtils.writeFile(agentsPath, agentsTemplate);
-        // 3. Update existing AI tool configuration files only
-        const configurators = ToolRegistry.getAll();
-        const slashConfigurators = SlashCommandRegistry.getAll();
-        const updatedFiles = [];
-        const createdFiles = [];
-        const failedFiles = [];
-        const updatedSlashFiles = [];
-        const failedSlashTools = [];
-        for (const configurator of configurators) {
-            const configFilePath = path.join(resolvedProjectPath, configurator.configFileName);
-            const fileExists = await FileSystemUtils.fileExists(configFilePath);
-            const shouldConfigure = fileExists || configurator.configFileName === 'AGENTS.md';
-            if (!shouldConfigure) {
+        // 2. Detect and handle legacy artifacts + upgrade legacy tools to new skills
+        const newlyConfiguredTools = await this.handleLegacyCleanup(resolvedProjectPath);
+        // 3. Find configured tools
+        const configuredTools = getConfiguredTools(resolvedProjectPath);
+        if (configuredTools.length === 0 && newlyConfiguredTools.length === 0) {
+            console.log(chalk.yellow('No configured tools found.'));
+            console.log(chalk.dim('Run "openspec init" to set up tools.'));
+            return;
+        }
+        // 4. Check version status for all configured tools
+        const toolStatuses = getAllToolVersionStatus(resolvedProjectPath, OPENSPEC_VERSION);
+        // 5. Smart update detection
+        const toolsNeedingUpdate = toolStatuses.filter((s) => s.needsUpdate);
+        const toolsUpToDate = toolStatuses.filter((s) => !s.needsUpdate);
+        if (!this.force && toolsNeedingUpdate.length === 0) {
+            // All tools are up to date
+            this.displayUpToDateMessage(toolStatuses);
+            return;
+        }
+        // 6. Display update plan
+        if (this.force) {
+            console.log(`Force updating ${configuredTools.length} tool(s): ${configuredTools.join(', ')}`);
+        }
+        else {
+            this.displayUpdatePlan(toolsNeedingUpdate, toolsUpToDate);
+        }
+        console.log();
+        // 7. Prepare templates
+        const skillTemplates = getSkillTemplates();
+        const commandContents = getCommandContents();
+        // 8. Update tools (all if force, otherwise only those needing update)
+        const toolsToUpdate = this.force ? configuredTools : toolsNeedingUpdate.map((s) => s.toolId);
+        const updatedTools = [];
+        const failedTools = [];
+        for (const toolId of toolsToUpdate) {
+            const tool = AI_TOOLS.find((t) => t.value === toolId);
+            if (!tool?.skillsDir)
                 continue;
-            }
+            const spinner = ora(`Updating ${tool.name}...`).start();
             try {
-                if (fileExists && !await FileSystemUtils.canWriteFile(configFilePath)) {
-                    throw new Error(`Insufficient permissions to modify ${configurator.configFileName}`);
+                const skillsDir = path.join(resolvedProjectPath, tool.skillsDir, 'skills');
+                // Update skill files
+                for (const { template, dirName } of skillTemplates) {
+                    const skillDir = path.join(skillsDir, dirName);
+                    const skillFile = path.join(skillDir, 'SKILL.md');
+                    const skillContent = generateSkillContent(template, OPENSPEC_VERSION);
+                    await FileSystemUtils.writeFile(skillFile, skillContent);
                 }
-                await configurator.configure(resolvedProjectPath, openspecPath);
-                updatedFiles.push(configurator.configFileName);
-                if (!fileExists) {
-                    createdFiles.push(configurator.configFileName);
+                // Update commands
+                const adapter = CommandAdapterRegistry.get(tool.value);
+                if (adapter) {
+                    const generatedCommands = generateCommands(commandContents, adapter);
+                    for (const cmd of generatedCommands) {
+                        const commandFile = path.join(resolvedProjectPath, cmd.path);
+                        await FileSystemUtils.writeFile(commandFile, cmd.fileContent);
+                    }
                 }
+                spinner.succeed(`Updated ${tool.name}`);
+                updatedTools.push(tool.name);
             }
             catch (error) {
-                failedFiles.push(configurator.configFileName);
-                console.error(`Failed to update ${configurator.configFileName}: ${error instanceof Error ? error.message : String(error)}`);
+                spinner.fail(`Failed to update ${tool.name}`);
+                failedTools.push({
+                    name: tool.name,
+                    error: error instanceof Error ? error.message : String(error)
+                });
             }
         }
-        for (const slashConfigurator of slashConfigurators) {
-            if (!slashConfigurator.isAvailable) {
-                continue;
+        // 9. Summary
+        console.log();
+        if (updatedTools.length > 0) {
+            console.log(chalk.green(`✓ Updated: ${updatedTools.join(', ')} (v${OPENSPEC_VERSION})`));
+        }
+        if (failedTools.length > 0) {
+            console.log(chalk.red(`✗ Failed: ${failedTools.map(f => `${f.name} (${f.error})`).join(', ')}`));
+        }
+        // 10. Show onboarding message for newly configured tools from legacy upgrade
+        if (newlyConfiguredTools.length > 0) {
+            console.log();
+            console.log(chalk.bold('Getting started:'));
+            console.log('  /opsx:new       Start a new change');
+            console.log('  /opsx:continue  Create the next artifact');
+            console.log('  /opsx:apply     Implement tasks');
+            console.log();
+            console.log(`Learn more: ${chalk.cyan('https://github.com/Fission-AI/OpenSpec')}`);
+        }
+        console.log();
+        console.log(chalk.dim('Restart your IDE for changes to take effect.'));
+    }
+    /**
+     * Display message when all tools are up to date.
+     */
+    displayUpToDateMessage(toolStatuses) {
+        const toolNames = toolStatuses.map((s) => s.toolId);
+        console.log(chalk.green(`✓ All ${toolStatuses.length} tool(s) up to date (v${OPENSPEC_VERSION})`));
+        console.log(chalk.dim(`  Tools: ${toolNames.join(', ')}`));
+        console.log();
+        console.log(chalk.dim('Use --force to refresh skills anyway.'));
+    }
+    /**
+     * Display the update plan showing which tools need updating.
+     */
+    displayUpdatePlan(needingUpdate, upToDate) {
+        const updates = needingUpdate.map((s) => {
+            const fromVersion = s.generatedByVersion ?? 'unknown';
+            return `${s.toolId} (${fromVersion} → ${OPENSPEC_VERSION})`;
+        });
+        console.log(`Updating ${needingUpdate.length} tool(s): ${updates.join(', ')}`);
+        if (upToDate.length > 0) {
+            const upToDateNames = upToDate.map((s) => s.toolId);
+            console.log(chalk.dim(`Already up to date: ${upToDateNames.join(', ')}`));
+        }
+    }
+    /**
+     * Detect and handle legacy OpenSpec artifacts.
+     * Unlike init, update warns but continues if legacy files found in non-interactive mode.
+     * Returns array of tool IDs that were newly configured during legacy upgrade.
+     */
+    async handleLegacyCleanup(projectPath) {
+        // Detect legacy artifacts
+        const detection = await detectLegacyArtifacts(projectPath);
+        if (!detection.hasLegacyArtifacts) {
+            return []; // No legacy artifacts found
+        }
+        // Show what was detected
+        console.log();
+        console.log(formatDetectionSummary(detection));
+        console.log();
+        const canPrompt = isInteractive();
+        if (this.force) {
+            // --force flag: proceed with cleanup automatically
+            await this.performLegacyCleanup(projectPath, detection);
+            // Then upgrade legacy tools to new skills
+            return this.upgradeLegacyTools(projectPath, detection, canPrompt);
+        }
+        if (!canPrompt) {
+            // Non-interactive mode without --force: warn and continue
+            // (Unlike init, update doesn't abort - user may just want to update skills)
+            console.log(chalk.yellow('⚠ Run with --force to auto-cleanup legacy files, or run interactively.'));
+            console.log();
+            return [];
+        }
+        // Interactive mode: prompt for confirmation
+        const { confirm } = await import('@inquirer/prompts');
+        const shouldCleanup = await confirm({
+            message: 'Upgrade and clean up legacy files?',
+            default: true,
+        });
+        if (shouldCleanup) {
+            await this.performLegacyCleanup(projectPath, detection);
+            // Then upgrade legacy tools to new skills
+            return this.upgradeLegacyTools(projectPath, detection, canPrompt);
+        }
+        else {
+            console.log(chalk.dim('Skipping legacy cleanup. Continuing with skill update...'));
+            console.log();
+            return [];
+        }
+    }
+    /**
+     * Perform cleanup of legacy artifacts.
+     */
+    async performLegacyCleanup(projectPath, detection) {
+        const spinner = ora('Cleaning up legacy files...').start();
+        const result = await cleanupLegacyArtifacts(projectPath, detection);
+        spinner.succeed('Legacy files cleaned up');
+        const summary = formatCleanupSummary(result);
+        if (summary) {
+            console.log();
+            console.log(summary);
+        }
+        console.log();
+    }
+    /**
+     * Upgrade legacy tools to new skills system.
+     * Returns array of tool IDs that were newly configured.
+     */
+    async upgradeLegacyTools(projectPath, detection, canPrompt) {
+        // Get tools that had legacy artifacts
+        const legacyTools = getToolsFromLegacyArtifacts(detection);
+        if (legacyTools.length === 0) {
+            return [];
+        }
+        // Get currently configured tools
+        const configuredTools = getConfiguredTools(projectPath);
+        const configuredSet = new Set(configuredTools);
+        // Filter to tools that aren't already configured
+        const unconfiguredLegacyTools = legacyTools.filter((t) => !configuredSet.has(t));
+        if (unconfiguredLegacyTools.length === 0) {
+            return [];
+        }
+        // Get valid tools (those with skillsDir)
+        const validToolIds = new Set(getToolsWithSkillsDir());
+        const validUnconfiguredTools = unconfiguredLegacyTools.filter((t) => validToolIds.has(t));
+        if (validUnconfiguredTools.length === 0) {
+            return [];
+        }
+        // Show what tools were detected from legacy artifacts
+        console.log(chalk.bold('Tools detected from legacy artifacts:'));
+        for (const toolId of validUnconfiguredTools) {
+            const tool = AI_TOOLS.find((t) => t.value === toolId);
+            console.log(`  • ${tool?.name || toolId}`);
+        }
+        console.log();
+        let selectedTools;
+        if (this.force || !canPrompt) {
+            // Non-interactive with --force: auto-select detected tools
+            selectedTools = validUnconfiguredTools;
+            console.log(`Setting up skills for: ${selectedTools.join(', ')}`);
+        }
+        else {
+            // Interactive mode: prompt for tool selection with detected tools pre-selected
+            const { searchableMultiSelect } = await import('../prompts/searchable-multi-select.js');
+            const sortedChoices = validUnconfiguredTools.map((toolId) => {
+                const tool = AI_TOOLS.find((t) => t.value === toolId);
+                return {
+                    name: tool?.name || toolId,
+                    value: toolId,
+                    configured: false,
+                    preSelected: true, // Pre-select all detected legacy tools
+                };
+            });
+            selectedTools = await searchableMultiSelect({
+                message: 'Select tools to set up with the new skill system:',
+                pageSize: 15,
+                choices: sortedChoices,
+                validate: (_selected) => true, // Allow empty selection (user can skip)
+            });
+            if (selectedTools.length === 0) {
+                console.log(chalk.dim('Skipping tool setup.'));
+                console.log();
+                return [];
             }
+        }
+        // Create skills for selected tools
+        const newlyConfigured = [];
+        const skillTemplates = getSkillTemplates();
+        const commandContents = getCommandContents();
+        for (const toolId of selectedTools) {
+            const tool = AI_TOOLS.find((t) => t.value === toolId);
+            if (!tool?.skillsDir)
+                continue;
+            const spinner = ora(`Setting up ${tool.name}...`).start();
             try {
-                const updated = await slashConfigurator.updateExisting(resolvedProjectPath, openspecPath);
-                updatedSlashFiles.push(...updated);
+                const skillsDir = path.join(projectPath, tool.skillsDir, 'skills');
+                // Create skill files
+                for (const { template, dirName } of skillTemplates) {
+                    const skillDir = path.join(skillsDir, dirName);
+                    const skillFile = path.join(skillDir, 'SKILL.md');
+                    const skillContent = generateSkillContent(template, OPENSPEC_VERSION);
+                    await FileSystemUtils.writeFile(skillFile, skillContent);
+                }
+                // Create commands
+                const adapter = CommandAdapterRegistry.get(tool.value);
+                if (adapter) {
+                    const generatedCommands = generateCommands(commandContents, adapter);
+                    for (const cmd of generatedCommands) {
+                        const commandFile = path.join(projectPath, cmd.path);
+                        await FileSystemUtils.writeFile(commandFile, cmd.fileContent);
+                    }
+                }
+                spinner.succeed(`Setup complete for ${tool.name}`);
+                newlyConfigured.push(toolId);
             }
             catch (error) {
-                failedSlashTools.push(slashConfigurator.toolId);
-                console.error(`Failed to update slash commands for ${slashConfigurator.toolId}: ${error instanceof Error ? error.message : String(error)}`);
+                spinner.fail(`Failed to set up ${tool.name}`);
+                console.log(chalk.red(`  ${error instanceof Error ? error.message : String(error)}`));
             }
         }
-        const summaryParts = [];
-        const instructionFiles = ['openspec/AGENTS.md'];
-        if (updatedFiles.includes('AGENTS.md')) {
-            instructionFiles.push(createdFiles.includes('AGENTS.md') ? 'AGENTS.md (created)' : 'AGENTS.md');
-        }
-        summaryParts.push(`Updated OpenSpec instructions (${instructionFiles.join(', ')})`);
-        const aiToolFiles = updatedFiles.filter((file) => file !== 'AGENTS.md');
-        if (aiToolFiles.length > 0) {
-            summaryParts.push(`Updated AI tool files: ${aiToolFiles.join(', ')}`);
-        }
-        if (updatedSlashFiles.length > 0) {
-            // Normalize to forward slashes for cross-platform log consistency
-            const normalized = updatedSlashFiles.map((p) => FileSystemUtils.toPosixPath(p));
-            summaryParts.push(`Updated slash commands: ${normalized.join(', ')}`);
-        }
-        const failedItems = [
-            ...failedFiles,
-            ...failedSlashTools.map((toolId) => `slash command refresh (${toolId})`),
-        ];
-        if (failedItems.length > 0) {
-            summaryParts.push(`Failed to update: ${failedItems.join(', ')}`);
-        }
-        console.log(summaryParts.join(' | '));
-        // No additional notes
+        if (newlyConfigured.length > 0) {
+            console.log();
+        }
+        return newlyConfigured;
     }
 }
 //# sourceMappingURL=update.js.map

package/dist/prompts/searchable-multi-select.d.ts

@@ -0,0 +1,27 @@
+interface Choice {
+    name: string;
+    value: string;
+    description?: string;
+    configured?: boolean;
+    configuredLabel?: string;
+    preSelected?: boolean;
+}
+interface Config {
+    message: string;
+    choices: Choice[];
+    pageSize?: number;
+    validate?: (selected: string[]) => boolean | string;
+}
+/**
+ * A searchable multi-select prompt with visible search box,
+ * selected items display, and intuitive keyboard navigation.
+ *
+ * - Type to filter choices
+ * - ↑↓ to navigate
+ * - Enter to add highlighted item
+ * - Backspace to remove last selected item (or delete search char)
+ * - Tab to confirm selections
+ */
+export declare function searchableMultiSelect(config: Config): Promise<string[]>;
+export default searchableMultiSelect;
+//# sourceMappingURL=searchable-multi-select.d.ts.map

package/dist/prompts/searchable-multi-select.js

@@ -0,0 +1,149 @@
+import chalk from 'chalk';
+/**
+ * Create the searchable multi-select prompt.
+ * Uses dynamic import to prevent pre-commit hook hangs (see #367).
+ */
+async function createSearchableMultiSelect() {
+    const { createPrompt, useState, useKeypress, useMemo, usePrefix, isEnterKey, isBackspaceKey, isUpKey, isDownKey, } = await import('@inquirer/core');
+    return createPrompt((config, done) => {
+        const { message, choices, pageSize = 15, validate } = config;
+        const [searchText, setSearchText] = useState('');
+        const [selectedValues, setSelectedValues] = useState(() => choices.filter(c => c.preSelected).map(c => c.value));
+        const [cursor, setCursor] = useState(0);
+        const [status, setStatus] = useState('idle');
+        const [error, setError] = useState(null);
+        const prefix = usePrefix({ status });
+        // Filter choices by search
+        const filteredChoices = useMemo(() => {
+            if (!searchText.trim())
+                return choices;
+            const term = searchText.toLowerCase();
+            return choices.filter((c) => c.name.toLowerCase().includes(term) ||
+                c.value.toLowerCase().includes(term));
+        }, [searchText, choices]);
+        const selectedSet = useMemo(() => new Set(selectedValues), [selectedValues]);
+        const choiceMap = useMemo(() => new Map(choices.map((c) => [c.value, c])), [choices]);
+        useKeypress((key) => {
+            if (status === 'done')
+                return;
+            // Tab to confirm
+            if (key.name === 'tab') {
+                if (validate) {
+                    const result = validate(selectedValues);
+                    if (result !== true) {
+                        setError(typeof result === 'string' ? result : 'Invalid');
+                        return;
+                    }
+                }
+                setStatus('done');
+                done(selectedValues);
+                return;
+            }
+            // Enter to add item
+            if (isEnterKey(key)) {
+                const choice = filteredChoices[cursor];
+                if (choice && !selectedSet.has(choice.value)) {
+                    setSelectedValues([...selectedValues, choice.value]);
+                    setSearchText('');
+                    setCursor(0);
+                }
+                return;
+            }
+            // Backspace to remove or delete search char
+            if (isBackspaceKey(key)) {
+                if (searchText === '' && selectedValues.length > 0) {
+                    setSelectedValues(selectedValues.slice(0, -1));
+                }
+                else {
+                    setSearchText(searchText.slice(0, -1));
+                    setCursor(0);
+                }
+                return;
+            }
+            // Navigation
+            if (isUpKey(key)) {
+                setCursor(Math.max(0, cursor - 1));
+                return;
+            }
+            if (isDownKey(key)) {
+                setCursor(Math.min(filteredChoices.length - 1, cursor + 1));
+                return;
+            }
+            // Character input - handle printable characters
+            if (key.name && key.name.length === 1 && !key.ctrl) {
+                setSearchText(searchText + key.name);
+                setCursor(0);
+            }
+        });
+        // Render done state
+        if (status === 'done') {
+            const names = selectedValues
+                .map((v) => choiceMap.get(v)?.name ?? v)
+                .join(', ');
+            return `${prefix} ${chalk.bold(message)} ${chalk.cyan(names || '(none)')}`;
+        }
+        // Render active state
+        const lines = [];
+        lines.push(`${prefix} ${chalk.bold(message)}`);
+        // Selected chips
+        const chips = selectedValues.length > 0
+            ? selectedValues
+                .map((v) => chalk.bgCyan.black(` ${choiceMap.get(v)?.name} `))
+                .join(' ')
+            : chalk.dim('(none selected)');
+        lines.push(`  Selected: ${chips}`);
+        // Search box
+        lines.push(`  Search: ${chalk.yellow('[')}${searchText || chalk.dim('type to filter')}${chalk.yellow(']')}`);
+        // Instructions
+        lines.push(`  ${chalk.cyan('↑↓')} navigate • ${chalk.cyan('Enter')} add • ${chalk.cyan('Backspace')} remove • ${chalk.cyan('Tab')} confirm`);
+        // List
+        if (filteredChoices.length === 0) {
+            lines.push(chalk.yellow('  No matches'));
+        }
+        else {
+            // Calculate pagination
+            const startIndex = Math.max(0, Math.min(cursor - Math.floor(pageSize / 2), filteredChoices.length - pageSize));
+            const endIndex = Math.min(startIndex + pageSize, filteredChoices.length);
+            const visibleChoices = filteredChoices.slice(startIndex, endIndex);
+            for (let i = 0; i < visibleChoices.length; i++) {
+                const item = visibleChoices[i];
+                const actualIndex = startIndex + i;
+                const isActive = actualIndex === cursor;
+                const selected = selectedSet.has(item.value);
+                const icon = selected ? chalk.green('◉') : chalk.dim('○');
+                const arrow = isActive ? chalk.cyan('›') : ' ';
+                const name = isActive ? chalk.cyan(item.name) : item.name;
+                const isRefresh = selected && item.configured;
+                const suffix = selected
+                    ? chalk.dim(isRefresh ? ' (refresh)' : ' (selected)')
+                    : '';
+                lines.push(`  ${arrow} ${icon} ${name}${suffix}`);
+            }
+            // Show pagination indicator if needed
+            if (filteredChoices.length > pageSize) {
+                const currentPage = Math.floor(cursor / pageSize) + 1;
+                const totalPages = Math.ceil(filteredChoices.length / pageSize);
+                lines.push(chalk.dim(`  (${currentPage}/${totalPages})`));
+            }
+        }
+        if (error)
+            lines.push(chalk.red(`  ${error}`));
+        return lines.join('\n');
+    });
+}
+/**
+ * A searchable multi-select prompt with visible search box,
+ * selected items display, and intuitive keyboard navigation.
+ *
+ * - Type to filter choices
+ * - ↑↓ to navigate
+ * - Enter to add highlighted item
+ * - Backspace to remove last selected item (or delete search char)
+ * - Tab to confirm selections
+ */
+export async function searchableMultiSelect(config) {
+    const prompt = await createSearchableMultiSelect();
+    return prompt(config);
+}
+export default searchableMultiSelect;
+//# sourceMappingURL=searchable-multi-select.js.map

package/dist/ui/ascii-patterns.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ASCII art animation patterns for the welcome screen.
+ * OpenSpec logo animation - diamond/rhombus shape with hollow center "O".
+ */
+/**
+ * Welcome animation frames - OpenSpec logo building from center
+ * 7 rows × 6 columns diamond with hollow center "O"
+ * Center bar is 2 cols × 3 rows (rows 3,4,5 cols 3,4)
+ * Each frame is an array of strings (lines of ASCII art)
+ * Grid: 6 cols × 2 chars = 12 chars wide
+ */
+export declare const WELCOME_ANIMATION: {
+    interval: number;
+    frames: string[][];
+};
+//# sourceMappingURL=ascii-patterns.d.ts.map