@codewalla_india/openspec 1.0.1

package/dist/core/working-set.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Working-set assembly (slice 4.1): the full set a root's declarations
+ * describe — the OpenSpec root and its referenced stores — as an
+ * agent-consumable brief. A local convenience
+ * computed from declared relationships, never a planning system; no
+ * clone/sync/launch machinery. Unresolvable members are reported, not
+ * guessed.
+ */
+import type { StoreDiagnostic } from './store/errors.js';
+import { type ReferenceIndexEntry } from './references.js';
+import { type ResolvedOpenSpecRoot } from './root-selection.js';
+export type WorkingSetRole = 'referenced_store';
+export interface WorkingSetMember {
+    role: WorkingSetRole;
+    id: string;
+    path?: string;
+    remote?: string;
+    fetch?: string;
+    status: StoreDiagnostic[];
+}
+export interface WorkingSet {
+    root: {
+        path: string;
+        source: ResolvedOpenSpecRoot['source'];
+        store_id?: string;
+        role: 'openspec_root';
+    };
+    members: WorkingSetMember[];
+    status: StoreDiagnostic[];
+}
+export interface AssembleWorkingSetInput {
+    root: ResolvedOpenSpecRoot;
+    referenceEntries: ReferenceIndexEntry[];
+    /** The composition's top-level status; the working set keeps only
+     * the registry-unreadable degradation (selected by code, never by
+     * position). */
+    topLevelStatus?: StoreDiagnostic[];
+}
+/** AVAILABLE = path present AND per-entry status empty. */
+export declare function isAvailableMember(member: WorkingSetMember): boolean;
+export declare function assembleWorkingSet(input: AssembleWorkingSetInput): WorkingSet;
+/**
+ * Pure builder for the `.code-workspace` editor view — one consumer of
+ * assembly, not the feature. Available members only.
+ */
+export declare function buildCodeWorkspaceJson(workingSet: WorkingSet, rootName: string): string;
+//# sourceMappingURL=working-set.d.ts.map

package/dist/core/working-set.js

@@ -0,0 +1,43 @@
+import { fetchRecipe } from './references.js';
+import { toRootOutput } from './root-selection.js';
+/** AVAILABLE = path present AND per-entry status empty. */
+export function isAvailableMember(member) {
+    return member.path !== undefined && member.status.length === 0;
+}
+export function assembleWorkingSet(input) {
+    const members = [];
+    for (const entry of input.referenceEntries) {
+        members.push({
+            role: 'referenced_store',
+            id: entry.store_id,
+            ...(entry.root !== undefined ? { path: entry.root } : {}),
+            ...(entry.root !== undefined && entry.status.length === 0
+                ? { fetch: fetchRecipe(entry.store_id) }
+                : {}),
+            status: entry.status,
+        });
+    }
+    const status = (input.topLevelStatus ?? []).filter((entry) => entry.code === 'relationship_registry_unreadable');
+    return {
+        root: { ...toRootOutput(input.root), role: 'openspec_root' },
+        members,
+        status,
+    };
+}
+/**
+ * Pure builder for the `.code-workspace` editor view — one consumer of
+ * assembly, not the feature. Available members only.
+ */
+export function buildCodeWorkspaceJson(workingSet, rootName) {
+    const folders = [
+        { name: rootName, path: workingSet.root.path },
+    ];
+    for (const member of workingSet.members) {
+        if (!isAvailableMember(member)) {
+            continue;
+        }
+        folders.push({ name: `ref:${member.id}`, path: member.path });
+    }
+    return JSON.stringify({ folders }, null, 2) + '\n';
+}
+//# sourceMappingURL=working-set.js.map

package/dist/core/worksets.d.ts

@@ -0,0 +1,75 @@
+import { StoreError } from './store/errors.js';
+/**
+ * Personal worksets (slice 7.1): purely local, manually composed,
+ * named working views. The whole feature's state lives under
+ * <globalDataDir>/worksets/ - the saved-views file plus the generated
+ * .code-workspace files - so deleting that one directory removes
+ * every trace. Nothing here is committed, shared, or derived from
+ * declarations, and nothing is ever written into a member folder.
+ */
+export declare const WORKSETS_DIR_NAME = "worksets";
+export declare const WORKSETS_FILE_NAME = "worksets.yaml";
+export interface WorksetPathOptions {
+    globalDataDir?: string;
+}
+export interface WorksetMember {
+    /** Display label; the .code-workspace folder name. */
+    name: string;
+    /** Absolute path to the member directory. */
+    path: string;
+}
+export interface Workset {
+    name: string;
+    /** Preferred opener id; validated only at open time. */
+    tool?: string;
+    /** Ordered; the first member is the primary (session cwd). */
+    members: WorksetMember[];
+}
+export interface WorksetsState {
+    version: 1;
+    worksets: Record<string, {
+        tool?: string;
+        members: WorksetMember[];
+    }>;
+}
+export declare function getWorksetsDir(options?: WorksetPathOptions): string;
+export declare function getWorksetsFilePath(options?: WorksetPathOptions): string;
+export declare function getWorksetCodeWorkspacePath(name: string, options?: WorksetPathOptions): string;
+export declare function validateWorksetName(name: string): string;
+/**
+ * Returns a problem description for a member list, or null when valid.
+ * Shared by the file parser (wrapping as invalid_workset_file) and the
+ * compose flow (wrapping as workset_member_invalid).
+ */
+export declare function memberListProblem(members: WorksetMember[]): string | null;
+export declare function memberLabelProblem(label: string): string | null;
+export declare function parseWorksetsState(content: string, options?: WorksetPathOptions): WorksetsState;
+export declare function serializeWorksetsState(state: WorksetsState, options?: WorksetPathOptions): string;
+/** Absent file reads as the empty state; a corrupt file throws. */
+export declare function readWorksetsState(options?: WorksetPathOptions): Promise<WorksetsState>;
+export declare function updateWorksetsState(updater: (state: WorksetsState) => WorksetsState | Promise<WorksetsState>, options?: WorksetPathOptions): Promise<WorksetsState>;
+/**
+ * Lock-scoped read without a write-back of the saved-views file.
+ * `open` uses this to read the state and regenerate the derived
+ * .code-workspace coherently; the lock is released before any spawn.
+ */
+export declare function withWorksetsLock<T>(fn: (state: WorksetsState) => T | Promise<T>, options?: WorksetPathOptions): Promise<T>;
+export declare function worksetNotFoundError(name: string, state: WorksetsState): StoreError;
+export declare function withWorkset(state: WorksetsState, workset: Workset): WorksetsState;
+export declare function withoutWorkset(state: WorksetsState, name: string): WorksetsState;
+/**
+ * Removes a saved workset and its derived .code-workspace under one
+ * lock. The derived-file cleanup runs AFTER the durable write (a
+ * failed write must not have already destroyed the artifact); a
+ * never-opened workset has no file - ENOENT is fine.
+ */
+export declare function removeWorkset(name: string, options?: WorksetPathOptions): Promise<void>;
+export declare function listWorksets(state: WorksetsState): Workset[];
+export declare function getWorkset(state: WorksetsState, name: string): Workset | null;
+/**
+ * The generated .code-workspace content: members in saved order with
+ * their saved names, absolute paths, two-space JSON, trailing newline
+ * (the working-set builder's conventions).
+ */
+export declare function buildWorksetCodeWorkspaceJson(members: WorksetMember[]): string;
+//# sourceMappingURL=worksets.d.ts.map

package/dist/core/worksets.js

@@ -0,0 +1,245 @@
+import * as nodeFs from 'node:fs';
+import * as path from 'node:path';
+import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
+import { z } from 'zod';
+import { getGlobalDataDir } from './global-config.js';
+import { FileSystemUtils } from '../utils/file-system.js';
+import { acquireFileLock, makeLockErrorFactory, pathIsFile, releaseFileLock, writeFileAtomically, } from './file-state.js';
+import { StoreError } from './store/errors.js';
+import { folderStyleNameProblem, isKebabId, KEBAB_ID_DESCRIPTION, KEBAB_ID_FIX, } from './id.js';
+import { formatZodIssues } from './zod-issues.js';
+const fs = nodeFs.promises;
+/**
+ * Personal worksets (slice 7.1): purely local, manually composed,
+ * named working views. The whole feature's state lives under
+ * <globalDataDir>/worksets/ - the saved-views file plus the generated
+ * .code-workspace files - so deleting that one directory removes
+ * every trace. Nothing here is committed, shared, or derived from
+ * declarations, and nothing is ever written into a member folder.
+ */
+export const WORKSETS_DIR_NAME = 'worksets';
+export const WORKSETS_FILE_NAME = 'worksets.yaml';
+const CODE_WORKSPACE_EXTENSION = '.code-workspace';
+export function getWorksetsDir(options = {}) {
+    return FileSystemUtils.joinPath(options.globalDataDir ?? getGlobalDataDir(), WORKSETS_DIR_NAME);
+}
+export function getWorksetsFilePath(options = {}) {
+    return FileSystemUtils.joinPath(getWorksetsDir(options), WORKSETS_FILE_NAME);
+}
+export function getWorksetCodeWorkspacePath(name, options = {}) {
+    return FileSystemUtils.joinPath(getWorksetsDir(options), `${name}${CODE_WORKSPACE_EXTENSION}`);
+}
+export function validateWorksetName(name) {
+    if (!isKebabId(name)) {
+        throw new StoreError(`Workset name '${name}' ${KEBAB_ID_DESCRIPTION}.`, 'invalid_workset_name', {
+            target: 'workset.name',
+            fix: KEBAB_ID_FIX,
+        });
+    }
+    return name;
+}
+/**
+ * Returns a problem description for a member list, or null when valid.
+ * Shared by the file parser (wrapping as invalid_workset_file) and the
+ * compose flow (wrapping as workset_member_invalid).
+ */
+export function memberListProblem(members) {
+    if (members.length === 0) {
+        return 'members must not be empty';
+    }
+    const seen = new Set();
+    for (const member of members) {
+        const labelProblem = memberLabelProblem(member.name);
+        if (labelProblem !== null) {
+            return labelProblem;
+        }
+        if (seen.has(member.name)) {
+            return `duplicate member name '${member.name}' (use the name=path form to label members distinctly)`;
+        }
+        seen.add(member.name);
+        if (!path.isAbsolute(member.path)) {
+            return `member path '${member.path}' must be absolute`;
+        }
+    }
+    return null;
+}
+export function memberLabelProblem(label) {
+    return folderStyleNameProblem(label, 'member name');
+}
+const WorksetMemberSchema = z
+    .object({
+    name: z.string(),
+    path: z.string(),
+})
+    .strict();
+const WorksetEntrySchema = z
+    .object({
+    tool: z.string().min(1).optional(),
+    members: z.array(WorksetMemberSchema),
+})
+    .strict();
+const WorksetsStateSchema = z
+    .object({
+    version: z.literal(1),
+    worksets: z.record(z.string(), WorksetEntrySchema),
+})
+    .strict();
+function invalidWorksetsFileError(message, options) {
+    return new StoreError(`Invalid worksets file: ${message}`, 'invalid_workset_file', {
+        target: 'workset.file',
+        fix: `Repair or remove ${getWorksetsFilePath(options)}.`,
+    });
+}
+export function parseWorksetsState(content, options = {}) {
+    let raw;
+    try {
+        raw = parseYaml(content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw invalidWorksetsFileError(message, options);
+    }
+    const result = WorksetsStateSchema.safeParse(raw);
+    if (!result.success) {
+        throw invalidWorksetsFileError(formatZodIssues(result.error), options);
+    }
+    for (const [name, entry] of Object.entries(result.data.worksets)) {
+        if (!isKebabId(name)) {
+            throw invalidWorksetsFileError(`workset name '${name}' ${KEBAB_ID_DESCRIPTION}`, options);
+        }
+        const problem = memberListProblem(entry.members);
+        if (problem !== null) {
+            throw invalidWorksetsFileError(`workset '${name}': ${problem}`, options);
+        }
+    }
+    return result.data;
+}
+export function serializeWorksetsState(state, options = {}) {
+    const result = WorksetsStateSchema.safeParse(state);
+    if (!result.success) {
+        throw invalidWorksetsFileError(formatZodIssues(result.error), options);
+    }
+    // The strict schema already guarantees the entry shape; the sort is
+    // the only real work here.
+    return stringifyYaml({
+        version: 1,
+        worksets: Object.fromEntries(Object.entries(result.data.worksets).sort(([a], [b]) => a.localeCompare(b))),
+    });
+}
+/** Absent file reads as the empty state; a corrupt file throws. */
+export async function readWorksetsState(options = {}) {
+    const filePath = getWorksetsFilePath(options);
+    if (!(await pathIsFile(filePath))) {
+        return { version: 1, worksets: {} };
+    }
+    return parseWorksetsState(await fs.readFile(filePath, 'utf-8'), options);
+}
+const worksetsLockError = makeLockErrorFactory({
+    createSubject: 'the worksets lock file',
+    busyMessage: 'The worksets file is busy.',
+    code: 'workset_file_busy',
+    target: 'workset.file',
+});
+export async function updateWorksetsState(updater, options = {}) {
+    return withWorksetsLock(async (state) => {
+        const next = await updater(state);
+        await writeFileAtomically(getWorksetsFilePath(options), serializeWorksetsState(next, options));
+        return next;
+    }, options);
+}
+/**
+ * Lock-scoped read without a write-back of the saved-views file.
+ * `open` uses this to read the state and regenerate the derived
+ * .code-workspace coherently; the lock is released before any spawn.
+ */
+export async function withWorksetsLock(fn, options = {}) {
+    const lockPath = `${getWorksetsFilePath(options)}.lock`;
+    const lock = await acquireFileLock({
+        lockPath,
+        errorFor: worksetsLockError,
+    });
+    try {
+        return await fn(await readWorksetsState(options));
+    }
+    finally {
+        await releaseFileLock(lock, lockPath);
+    }
+}
+export function worksetNotFoundError(name, state) {
+    const savedNames = Object.keys(state.worksets).sort((a, b) => a.localeCompare(b));
+    return new StoreError(`Workset '${name}' is not saved on this machine.`, 'workset_not_found', {
+        target: 'workset.name',
+        fix: savedNames.length > 0
+            ? `Saved worksets: ${savedNames.join(', ')}. See them with: openspec workset list`
+            : `Create it first: openspec workset create ${name}`,
+    });
+}
+export function withWorkset(state, workset) {
+    if (state.worksets[workset.name] !== undefined) {
+        throw new StoreError(`Workset '${workset.name}' already exists.`, 'workset_exists', {
+            target: 'workset.name',
+            fix: `Choose another name, or remove it first: openspec workset remove ${workset.name}`,
+        });
+    }
+    return {
+        version: 1,
+        worksets: {
+            ...state.worksets,
+            [workset.name]: {
+                ...(workset.tool !== undefined ? { tool: workset.tool } : {}),
+                members: workset.members,
+            },
+        },
+    };
+}
+export function withoutWorkset(state, name) {
+    if (state.worksets[name] === undefined) {
+        throw worksetNotFoundError(name, state);
+    }
+    const remaining = { ...state.worksets };
+    delete remaining[name];
+    return { version: 1, worksets: remaining };
+}
+/**
+ * Removes a saved workset and its derived .code-workspace under one
+ * lock. The derived-file cleanup runs AFTER the durable write (a
+ * failed write must not have already destroyed the artifact); a
+ * never-opened workset has no file - ENOENT is fine.
+ */
+export async function removeWorkset(name, options = {}) {
+    await withWorksetsLock(async (state) => {
+        const next = withoutWorkset(state, name);
+        await writeFileAtomically(getWorksetsFilePath(options), serializeWorksetsState(next, options));
+        await fs.rm(getWorksetCodeWorkspacePath(name, options), { force: true });
+    }, options);
+}
+function toWorkset(name, entry) {
+    return {
+        name,
+        ...(entry.tool !== undefined ? { tool: entry.tool } : {}),
+        members: entry.members,
+    };
+}
+export function listWorksets(state) {
+    return Object.entries(state.worksets)
+        .map(([name, entry]) => toWorkset(name, entry))
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+export function getWorkset(state, name) {
+    const entry = state.worksets[name];
+    return entry === undefined ? null : toWorkset(name, entry);
+}
+/**
+ * The generated .code-workspace content: members in saved order with
+ * their saved names, absolute paths, two-space JSON, trailing newline
+ * (the working-set builder's conventions).
+ */
+export function buildWorksetCodeWorkspaceJson(members) {
+    return (JSON.stringify({
+        folders: members.map((member) => ({
+            name: member.name,
+            path: member.path,
+        })),
+    }, null, 2) + '\n');
+}
+//# sourceMappingURL=worksets.js.map

package/dist/core/zod-issues.d.ts

@@ -0,0 +1,4 @@
+import type { z } from 'zod';
+/** One rendering for zod issues across every state/config parser. */
+export declare function formatZodIssues(error: z.ZodError, fallbackLocation?: string): string;
+//# sourceMappingURL=zod-issues.d.ts.map

package/dist/core/zod-issues.js

@@ -0,0 +1,10 @@
+/** One rendering for zod issues across every state/config parser. */
+export function formatZodIssues(error, fallbackLocation = 'root') {
+    return error.issues
+        .map((issue) => {
+        const location = issue.path.length > 0 ? issue.path.join('.') : fallbackLocation;
+        return `${location}: ${issue.message}`;
+    })
+        .join('; ');
+}
+//# sourceMappingURL=zod-issues.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

package/dist/telemetry/config.d.ts

@@ -0,0 +1,38 @@
+export declare const CONFIG_DIR_NAME = "openspec";
+export declare const CONFIG_FILE_NAME = "config.json";
+export interface TelemetryConfig {
+    anonymousId?: string;
+    noticeSeen?: boolean;
+}
+export interface GlobalConfig {
+    telemetry?: TelemetryConfig;
+    [key: string]: unknown;
+}
+/**
+ * Get the path to the global config file.
+ * Follows XDG Base Directory Specification and platform conventions.
+ *
+ * - All platforms: $XDG_CONFIG_HOME/openspec/ if XDG_CONFIG_HOME is set
+ * - Unix/macOS fallback: ~/.config/openspec/
+ * - Windows fallback: %APPDATA%/openspec/
+ */
+export declare function getConfigPath(): string;
+/**
+ * Read the global config file.
+ * Returns an empty object if the file doesn't exist.
+ */
+export declare function readConfig(): Promise<GlobalConfig>;
+/**
+ * Write to the global config file.
+ * Preserves existing fields and merges in new values.
+ */
+export declare function writeConfig(updates: Partial<GlobalConfig>): Promise<void>;
+/**
+ * Get the telemetry config section.
+ */
+export declare function getTelemetryConfig(): Promise<TelemetryConfig>;
+/**
+ * Update the telemetry config section.
+ */
+export declare function updateTelemetryConfig(updates: Partial<TelemetryConfig>): Promise<void>;
+//# sourceMappingURL=config.d.ts.map