@thiagodiogo/pastelsdd 1.0.0-beta.1

package/dist/core/workspace/skills.js

@@ -0,0 +1,334 @@
+import * as nodeFs from 'node:fs';
+import { createRequire } from 'node:module';
+import { FileSystemUtils } from '../../utils/file-system.js';
+import { transformToHyphenCommands } from '../../utils/command-references.js';
+import { AI_TOOLS } from '../config.js';
+import { getGlobalConfig } from '../global-config.js';
+import { getProfileWorkflows } from '../profiles.js';
+import { generateSkillContent, getSkillTemplates, getToolSkillStatus, getToolsWithSkillsDir, extractGeneratedByVersion, } from '../shared/index.js';
+const require = createRequire(import.meta.url);
+const { version: PASTELSDD_VERSION } = require('../../../package.json');
+const fs = nodeFs.promises;
+function resolveWorkspaceSkillProfileContext() {
+    const globalConfig = getGlobalConfig();
+    const profile = globalConfig.profile ?? 'core';
+    const delivery = globalConfig.delivery ?? 'both';
+    const workflowIds = [...getProfileWorkflows(profile, globalConfig.workflows)];
+    const deliveryNotice = delivery === 'skills'
+        ? null
+        : 'Workspace setup installs skills only; workspace command generation is not part of this slice.';
+    return {
+        profile,
+        delivery,
+        workflowIds,
+        deliveryNotice,
+    };
+}
+export function getCurrentWorkspaceSkillProfileSelection() {
+    const profileContext = resolveWorkspaceSkillProfileContext();
+    return {
+        profile: profileContext.profile,
+        delivery: profileContext.delivery,
+        workflow_ids: profileContext.workflowIds,
+    };
+}
+function arraysEqual(left, right) {
+    const leftValues = left ?? [];
+    if (leftValues.length !== right.length) {
+        return false;
+    }
+    const leftSet = new Set(leftValues);
+    const rightSet = new Set(right);
+    if (leftSet.size !== rightSet.size) {
+        return false;
+    }
+    return [...leftSet].every((value) => rightSet.has(value));
+}
+export function hasWorkspaceSkillProfileDrift(state) {
+    const workspaceSkills = state?.workspace_skills;
+    if (!workspaceSkills) {
+        return false;
+    }
+    const current = getCurrentWorkspaceSkillProfileSelection();
+    return (workspaceSkills.last_applied_profile !== current.profile ||
+        workspaceSkills.last_applied_delivery !== current.delivery ||
+        !arraysEqual(workspaceSkills.last_applied_workflow_ids, current.workflow_ids));
+}
+function makeBaseWorkspaceSkillReport(selectedAgentIds, profileContext = resolveWorkspaceSkillProfileContext()) {
+    return {
+        profile: profileContext.profile,
+        delivery: profileContext.delivery,
+        workflow_ids: profileContext.workflowIds,
+        selected_agents: selectedAgentIds,
+        skills_only: true,
+        delivery_notice: profileContext.deliveryNotice,
+        generated: [],
+        added: [],
+        refreshed: [],
+        removed: [],
+        skipped: [],
+        failed: [],
+    };
+}
+export function getWorkspaceSkillCapableTools() {
+    return AI_TOOLS.filter((tool) => Boolean(tool.skillsDir));
+}
+export function getWorkspaceSkillToolIds() {
+    return getToolsWithSkillsDir();
+}
+export function parseWorkspaceSkillToolsValue(rawTools) {
+    const raw = rawTools.trim();
+    if (raw.length === 0) {
+        throw new Error('The --tools option requires a value. Use "all", "none", or a comma-separated list of agent IDs.');
+    }
+    const availableTools = getWorkspaceSkillToolIds();
+    const availableSet = new Set(availableTools);
+    const availableList = ['all', 'none', ...availableTools].join(', ');
+    const lowerRaw = raw.toLowerCase();
+    if (lowerRaw === 'all') {
+        return availableTools;
+    }
+    if (lowerRaw === 'none') {
+        return [];
+    }
+    const tokens = raw
+        .split(',')
+        .map((token) => token.trim())
+        .filter((token) => token.length > 0);
+    if (tokens.length === 0) {
+        throw new Error('The --tools option requires at least one agent ID when not using "all" or "none".');
+    }
+    const normalizedTokens = tokens.map((token) => token.toLowerCase());
+    if (normalizedTokens.some((token) => token === 'all' || token === 'none')) {
+        throw new Error('Cannot combine reserved values "all" or "none" with specific agent IDs.');
+    }
+    const invalidTokens = tokens.filter((_token, index) => !availableSet.has(normalizedTokens[index]));
+    if (invalidTokens.length > 0) {
+        throw new Error(`Invalid agent(s): ${invalidTokens.join(', ')}. Available values: ${availableList}`);
+    }
+    const deduped = [];
+    for (const token of normalizedTokens) {
+        if (!deduped.includes(token)) {
+            deduped.push(token);
+        }
+    }
+    return deduped;
+}
+export function createWorkspaceSkillSkippedReport(reason, message) {
+    const report = makeBaseWorkspaceSkillReport([]);
+    report.skipped.push({
+        reason,
+        message,
+    });
+    return report;
+}
+function getWorkspaceSkillTool(toolId) {
+    const tool = getWorkspaceSkillCapableTools().find((candidate) => candidate.value === toolId);
+    if (!tool) {
+        throw new Error(`Unknown workspace skill agent '${toolId}'.`);
+    }
+    return tool;
+}
+function getWorkspaceSkillDirectoryForTool(workspaceRoot, tool) {
+    return FileSystemUtils.joinPath(workspaceRoot, tool.skillsDir, 'skills');
+}
+export function getWorkspaceSkillDirectory(workspaceRoot, toolId) {
+    return getWorkspaceSkillDirectoryForTool(workspaceRoot, getWorkspaceSkillTool(toolId));
+}
+function makeAgentResult(workspaceRoot, tool, workflowIds) {
+    return {
+        tool_id: tool.value,
+        name: tool.name,
+        skills_path: getWorkspaceSkillDirectoryForTool(workspaceRoot, tool),
+        workflow_ids: workflowIds,
+    };
+}
+function getManagedWorkspaceSkillEntries() {
+    return getSkillTemplates().map(({ workflowId, dirName }) => ({ workflowId, dirName }));
+}
+async function pathExists(targetPath) {
+    try {
+        await fs.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isPastelsddManagedSkillDir(skillDir) {
+    const skillFile = FileSystemUtils.joinPath(skillDir, 'SKILL.md');
+    return extractGeneratedByVersion(skillFile) !== null;
+}
+async function removeManagedWorkflowSkillDirs(workspaceRoot, tool, desiredWorkflowIds, reason) {
+    const desiredSet = new Set(desiredWorkflowIds);
+    const skillsDir = getWorkspaceSkillDirectoryForTool(workspaceRoot, tool);
+    const removedWorkflowIds = [];
+    for (const { workflowId, dirName } of getManagedWorkspaceSkillEntries()) {
+        if (desiredSet.has(workflowId)) {
+            continue;
+        }
+        const skillDir = FileSystemUtils.joinPath(skillsDir, dirName);
+        if (!(await pathExists(skillDir))) {
+            continue;
+        }
+        if (!isPastelsddManagedSkillDir(skillDir)) {
+            continue;
+        }
+        await fs.rm(skillDir, { recursive: true, force: true });
+        removedWorkflowIds.push(workflowId);
+    }
+    if (removedWorkflowIds.length === 0) {
+        return null;
+    }
+    return {
+        ...makeAgentResult(workspaceRoot, tool, removedWorkflowIds),
+        reason,
+    };
+}
+export async function generateWorkspaceAgentSkills(workspaceRoot, selectedAgentIds) {
+    const profileContext = resolveWorkspaceSkillProfileContext();
+    const report = makeBaseWorkspaceSkillReport(selectedAgentIds, profileContext);
+    if (selectedAgentIds.length === 0) {
+        report.skipped.push({
+            reason: 'no_agents_selected',
+            message: 'No workspace agent skills were selected.',
+        });
+        return report;
+    }
+    const skillTemplates = getSkillTemplates(profileContext.workflowIds);
+    if (skillTemplates.length === 0) {
+        for (const toolId of selectedAgentIds) {
+            const tool = getWorkspaceSkillTool(toolId);
+            report.skipped.push({
+                tool_id: tool.value,
+                name: tool.name,
+                reason: 'no_profile_workflows',
+                message: 'The active global profile does not select any workflows.',
+            });
+        }
+        return report;
+    }
+    for (const toolId of selectedAgentIds) {
+        const tool = getWorkspaceSkillTool(toolId);
+        const wasConfigured = getToolSkillStatus(workspaceRoot, tool.value).configured;
+        try {
+            const skillsDir = getWorkspaceSkillDirectoryForTool(workspaceRoot, tool);
+            const transformer = tool.value === 'opencode' || tool.value === 'pi' ? transformToHyphenCommands : undefined;
+            for (const { template, dirName } of skillTemplates) {
+                const skillFile = FileSystemUtils.joinPath(skillsDir, dirName, 'SKILL.md');
+                const skillContent = generateSkillContent(template, PASTELSDD_VERSION, transformer);
+                await FileSystemUtils.writeFile(skillFile, skillContent);
+            }
+            const result = makeAgentResult(workspaceRoot, tool, profileContext.workflowIds);
+            if (wasConfigured) {
+                report.refreshed.push(result);
+            }
+            else {
+                report.generated.push(result);
+            }
+        }
+        catch (error) {
+            report.failed.push({
+                tool_id: tool.value,
+                name: tool.name,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return report;
+}
+export async function updateWorkspaceAgentSkills(workspaceRoot, selectedAgentIds, previousSkillState) {
+    const profileContext = resolveWorkspaceSkillProfileContext();
+    const report = makeBaseWorkspaceSkillReport(selectedAgentIds, profileContext);
+    const previousSelectedAgentIds = previousSkillState?.selected_agents ?? [];
+    const previousSelectedSet = new Set(previousSelectedAgentIds);
+    const selectedSet = new Set(selectedAgentIds);
+    const skillTemplates = getSkillTemplates(profileContext.workflowIds);
+    for (const toolId of previousSelectedAgentIds) {
+        if (selectedSet.has(toolId)) {
+            continue;
+        }
+        const tool = getWorkspaceSkillTool(toolId);
+        try {
+            const removed = await removeManagedWorkflowSkillDirs(workspaceRoot, tool, [], 'agent_unselected');
+            if (removed) {
+                report.removed.push(removed);
+            }
+        }
+        catch (error) {
+            report.failed.push({
+                tool_id: tool.value,
+                name: tool.name,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    if (selectedAgentIds.length === 0) {
+        if (report.removed.length === 0) {
+            report.skipped.push({
+                reason: previousSkillState ? 'no_agents_selected' : 'no_stored_agent_selection',
+                message: previousSkillState
+                    ? 'No workspace agent skills were selected.'
+                    : 'No workspace agent skill selection is stored. Pass --tools <ids> to install skills.',
+            });
+        }
+        return report;
+    }
+    if (skillTemplates.length === 0) {
+        for (const toolId of selectedAgentIds) {
+            const tool = getWorkspaceSkillTool(toolId);
+            try {
+                const removed = await removeManagedWorkflowSkillDirs(workspaceRoot, tool, [], 'workflow_unselected');
+                if (removed) {
+                    report.removed.push(removed);
+                }
+            }
+            catch (error) {
+                report.failed.push({
+                    tool_id: tool.value,
+                    name: tool.name,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+            report.skipped.push({
+                tool_id: tool.value,
+                name: tool.name,
+                reason: 'no_profile_workflows',
+                message: 'The active global profile does not select any workflows.',
+            });
+        }
+        return report;
+    }
+    for (const toolId of selectedAgentIds) {
+        const tool = getWorkspaceSkillTool(toolId);
+        try {
+            const skillsDir = getWorkspaceSkillDirectoryForTool(workspaceRoot, tool);
+            const transformer = tool.value === 'opencode' || tool.value === 'pi' ? transformToHyphenCommands : undefined;
+            for (const { template, dirName } of skillTemplates) {
+                const skillFile = FileSystemUtils.joinPath(skillsDir, dirName, 'SKILL.md');
+                const skillContent = generateSkillContent(template, PASTELSDD_VERSION, transformer);
+                await FileSystemUtils.writeFile(skillFile, skillContent);
+            }
+            const removed = await removeManagedWorkflowSkillDirs(workspaceRoot, tool, profileContext.workflowIds, 'workflow_unselected');
+            if (removed) {
+                report.removed.push(removed);
+            }
+            const result = makeAgentResult(workspaceRoot, tool, profileContext.workflowIds);
+            if (previousSelectedSet.has(toolId)) {
+                report.refreshed.push(result);
+            }
+            else {
+                report.added.push(result);
+            }
+        }
+        catch (error) {
+            report.failed.push({
+                tool_id: tool.value,
+                name: tool.name,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return report;
+}
+//# sourceMappingURL=skills.js.map

package/dist/core/workspace/state-io.d.ts

@@ -0,0 +1,10 @@
+import { type WorkspaceViewState } from './foundation.js';
+export declare function isWorkspaceRoot(candidateRoot: string): Promise<boolean>;
+export declare function findWorkspaceRoot(startPath?: string): Promise<string | null>;
+export declare function workspaceStateFileExistsSync(workspaceRoot: string): boolean;
+export declare function readWorkspaceViewState(workspaceRoot: string): Promise<WorkspaceViewState>;
+export declare function readWorkspaceViewStateSync(workspaceRoot: string): WorkspaceViewState | null;
+export declare function readOptionalWorkspaceViewState(workspaceRoot: string): Promise<WorkspaceViewState | null>;
+export declare function writeWorkspaceViewState(workspaceRoot: string, state: WorkspaceViewState): Promise<void>;
+export declare function workspaceChangesDirExists(workspaceRoot: string): Promise<boolean>;
+//# sourceMappingURL=state-io.d.ts.map

package/dist/core/workspace/state-io.js

@@ -0,0 +1,119 @@
+import * as nodeFs from 'node:fs';
+import * as path from 'node:path';
+import { FileSystemUtils } from '../../utils/file-system.js';
+import { getWorkspaceChangesDir, getWorkspaceViewStatePath, parseWorkspaceViewState, serializeWorkspaceViewState, } from './foundation.js';
+import { getWorkspaceLegacyLocalStatePath, getWorkspaceLegacySharedStatePath, parseWorkspaceLocalState, parseWorkspaceSharedState, workspaceStatePartsToViewState, } from './legacy-state.js';
+const fs = nodeFs.promises;
+async function pathIsFile(filePath) {
+    try {
+        return (await fs.stat(filePath)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function pathIsDirectory(dirPath) {
+    try {
+        return (await fs.stat(dirPath)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function pathExistsAsFile(filePath) {
+    try {
+        return nodeFs.statSync(filePath).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function isFileNotFoundError(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'code' in error &&
+        error.code === 'ENOENT');
+}
+async function getSearchStartDirectory(startPath) {
+    const resolvedStart = path.resolve(startPath);
+    try {
+        const stats = await fs.stat(resolvedStart);
+        const searchStart = stats.isDirectory() ? resolvedStart : path.dirname(resolvedStart);
+        return FileSystemUtils.canonicalizeExistingPath(searchStart);
+    }
+    catch {
+        return resolvedStart;
+    }
+}
+export async function isWorkspaceRoot(candidateRoot) {
+    return ((await pathIsFile(getWorkspaceViewStatePath(candidateRoot))) ||
+        (await pathIsFile(getWorkspaceLegacySharedStatePath(candidateRoot))));
+}
+export async function findWorkspaceRoot(startPath = process.cwd()) {
+    let currentDir = await getSearchStartDirectory(startPath);
+    while (true) {
+        if (await isWorkspaceRoot(currentDir)) {
+            return FileSystemUtils.canonicalizeExistingPath(currentDir);
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            return null;
+        }
+        currentDir = parentDir;
+    }
+}
+export function workspaceStateFileExistsSync(workspaceRoot) {
+    return (pathExistsAsFile(getWorkspaceViewStatePath(workspaceRoot)) ||
+        pathExistsAsFile(getWorkspaceLegacySharedStatePath(workspaceRoot)));
+}
+export async function readWorkspaceViewState(workspaceRoot) {
+    const viewStatePath = getWorkspaceViewStatePath(workspaceRoot);
+    if (await pathIsFile(viewStatePath)) {
+        return parseWorkspaceViewState(await fs.readFile(viewStatePath, 'utf-8'));
+    }
+    const legacySharedState = parseWorkspaceSharedState(await fs.readFile(getWorkspaceLegacySharedStatePath(workspaceRoot), 'utf-8'));
+    let legacyLocalState = null;
+    try {
+        legacyLocalState = parseWorkspaceLocalState(await fs.readFile(getWorkspaceLegacyLocalStatePath(workspaceRoot), 'utf-8'));
+    }
+    catch (error) {
+        if (!isFileNotFoundError(error)) {
+            throw error;
+        }
+    }
+    return workspaceStatePartsToViewState(legacySharedState, legacyLocalState);
+}
+export function readWorkspaceViewStateSync(workspaceRoot) {
+    const viewStatePath = getWorkspaceViewStatePath(workspaceRoot);
+    if (pathExistsAsFile(viewStatePath)) {
+        return parseWorkspaceViewState(nodeFs.readFileSync(viewStatePath, 'utf-8'));
+    }
+    const legacySharedPath = getWorkspaceLegacySharedStatePath(workspaceRoot);
+    if (!pathExistsAsFile(legacySharedPath)) {
+        return null;
+    }
+    const legacySharedState = parseWorkspaceSharedState(nodeFs.readFileSync(legacySharedPath, 'utf-8'));
+    const legacyLocalPath = getWorkspaceLegacyLocalStatePath(workspaceRoot);
+    const legacyLocalState = pathExistsAsFile(legacyLocalPath)
+        ? parseWorkspaceLocalState(nodeFs.readFileSync(legacyLocalPath, 'utf-8'))
+        : null;
+    return workspaceStatePartsToViewState(legacySharedState, legacyLocalState);
+}
+export async function readOptionalWorkspaceViewState(workspaceRoot) {
+    try {
+        return await readWorkspaceViewState(workspaceRoot);
+    }
+    catch (error) {
+        if (isFileNotFoundError(error)) {
+            return null;
+        }
+        throw error;
+    }
+}
+export async function writeWorkspaceViewState(workspaceRoot, state) {
+    await FileSystemUtils.writeFile(getWorkspaceViewStatePath(workspaceRoot), serializeWorkspaceViewState(state));
+}
+export async function workspaceChangesDirExists(workspaceRoot) {
+    return pathIsDirectory(getWorkspaceChangesDir(workspaceRoot));
+}
+//# sourceMappingURL=state-io.js.map

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './cli/index.js';
+export * from './core/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from './cli/index.js';
+export * from './core/index.js';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,28 @@
+interface Choice {
+    name: string;
+    value: string;
+    description?: string;
+    configured?: boolean;
+    detected?: 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
+ * - Space to toggle highlighted item selection
+ * - Backspace to remove last selected item (or delete search char)
+ * - Enter 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,159 @@
+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;
+            // Enter to confirm/submit
+            if (isEnterKey(key)) {
+                if (validate) {
+                    const result = validate(selectedValues);
+                    if (result !== true) {
+                        setError(typeof result === 'string' ? result : 'Invalid');
+                        return;
+                    }
+                }
+                setStatus('done');
+                done(selectedValues);
+                return;
+            }
+            // Space to toggle selection
+            if (key.name === 'space') {
+                const choice = filteredChoices[cursor];
+                if (choice) {
+                    if (selectedSet.has(choice.value)) {
+                        setSelectedValues(selectedValues.filter(v => v !== choice.value));
+                    }
+                    else {
+                        setSelectedValues([...selectedValues, choice.value]);
+                    }
+                }
+                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('Space')} toggle • ${chalk.cyan('Backspace')} remove • ${chalk.cyan('Enter')} 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 statusLabel = !selected
+                    ? item.configured
+                        ? ' (configured)'
+                        : item.detected
+                            ? ' (detected)'
+                            : ''
+                    : '';
+                const suffix = selected
+                    ? chalk.dim(isRefresh ? ' (refresh)' : ' (selected)')
+                    : chalk.dim(statusLabel);
+                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
+ * - Space to toggle highlighted item selection
+ * - Backspace to remove last selected item (or delete search char)
+ * - Enter to confirm selections
+ */
+export async function searchableMultiSelect(config) {
+    const prompt = await createSearchableMultiSelect();
+    return prompt(config);
+}
+export default searchableMultiSelect;
+//# sourceMappingURL=searchable-multi-select.js.map