@kbdavis07/openspec 1.5.0-nov.1

package/dist/core/view.js

@@ -0,0 +1,168 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import chalk from 'chalk';
+import { getTaskProgressForChange } from '../utils/task-progress.js';
+import { MarkdownParser } from './parsers/markdown-parser.js';
+export class ViewCommand {
+    async execute(targetPath = '.') {
+        const openspecDir = path.join(targetPath, 'openspec');
+        if (!fs.existsSync(openspecDir)) {
+            console.error(chalk.red('No openspec directory found'));
+            process.exit(1);
+        }
+        console.log(chalk.bold('\nOpenSpec Dashboard\n'));
+        console.log('═'.repeat(60));
+        // Get changes and specs data
+        const changesData = await this.getChangesData(openspecDir);
+        const specsData = await this.getSpecsData(openspecDir);
+        // Display summary metrics
+        this.displaySummary(changesData, specsData);
+        // Display draft changes
+        if (changesData.draft.length > 0) {
+            console.log(chalk.bold.gray('\nDraft Changes'));
+            console.log('─'.repeat(60));
+            changesData.draft.forEach((change) => {
+                console.log(`  ${chalk.gray('○')} ${change.name}`);
+            });
+        }
+        // Display active changes
+        if (changesData.active.length > 0) {
+            console.log(chalk.bold.cyan('\nActive Changes'));
+            console.log('─'.repeat(60));
+            changesData.active.forEach((change) => {
+                const progressBar = this.createProgressBar(change.progress.completed, change.progress.total);
+                const percentage = change.progress.total > 0
+                    ? Math.round((change.progress.completed / change.progress.total) * 100)
+                    : 0;
+                console.log(`  ${chalk.yellow('◉')} ${chalk.bold(change.name.padEnd(30))} ${progressBar} ${chalk.dim(`${percentage}%`)}`);
+            });
+        }
+        // Display completed changes
+        if (changesData.completed.length > 0) {
+            console.log(chalk.bold.green('\nCompleted Changes'));
+            console.log('─'.repeat(60));
+            changesData.completed.forEach((change) => {
+                console.log(`  ${chalk.green('✓')} ${change.name}`);
+            });
+        }
+        // Display specifications
+        if (specsData.length > 0) {
+            console.log(chalk.bold.blue('\nSpecifications'));
+            console.log('─'.repeat(60));
+            // Sort specs by requirement count (descending)
+            specsData.sort((a, b) => b.requirementCount - a.requirementCount);
+            specsData.forEach(spec => {
+                const reqLabel = spec.requirementCount === 1 ? 'requirement' : 'requirements';
+                console.log(`  ${chalk.blue('▪')} ${chalk.bold(spec.name.padEnd(30))} ${chalk.dim(`${spec.requirementCount} ${reqLabel}`)}`);
+            });
+        }
+        console.log('\n' + '═'.repeat(60));
+        console.log(chalk.dim(`\nUse ${chalk.white('openspec list --changes')} or ${chalk.white('openspec list --specs')} for detailed views`));
+    }
+    async getChangesData(openspecDir) {
+        const changesDir = path.join(openspecDir, 'changes');
+        if (!fs.existsSync(changesDir)) {
+            return { draft: [], active: [], completed: [] };
+        }
+        const draft = [];
+        const active = [];
+        const completed = [];
+        const entries = fs.readdirSync(changesDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory() && entry.name !== 'archive') {
+                const progress = await getTaskProgressForChange(changesDir, entry.name, path.dirname(openspecDir));
+                if (progress.total === 0) {
+                    // No tasks defined yet - still in planning/draft phase
+                    draft.push({ name: entry.name });
+                }
+                else if (progress.completed === progress.total) {
+                    // All tasks complete
+                    completed.push({ name: entry.name });
+                }
+                else {
+                    // Has tasks but not all complete
+                    active.push({ name: entry.name, progress });
+                }
+            }
+        }
+        // Sort all categories by name for deterministic ordering
+        draft.sort((a, b) => a.name.localeCompare(b.name));
+        // Sort active changes by completion percentage (ascending) and then by name
+        active.sort((a, b) => {
+            const percentageA = a.progress.total > 0 ? a.progress.completed / a.progress.total : 0;
+            const percentageB = b.progress.total > 0 ? b.progress.completed / b.progress.total : 0;
+            if (percentageA < percentageB)
+                return -1;
+            if (percentageA > percentageB)
+                return 1;
+            return a.name.localeCompare(b.name);
+        });
+        completed.sort((a, b) => a.name.localeCompare(b.name));
+        return { draft, active, completed };
+    }
+    async getSpecsData(openspecDir) {
+        const specsDir = path.join(openspecDir, 'specs');
+        if (!fs.existsSync(specsDir)) {
+            return [];
+        }
+        const specs = [];
+        const entries = fs.readdirSync(specsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const specFile = path.join(specsDir, entry.name, 'spec.md');
+                if (fs.existsSync(specFile)) {
+                    try {
+                        const content = fs.readFileSync(specFile, 'utf-8');
+                        const parser = new MarkdownParser(content);
+                        const spec = parser.parseSpec(entry.name);
+                        const requirementCount = spec.requirements.length;
+                        specs.push({ name: entry.name, requirementCount });
+                    }
+                    catch (error) {
+                        // If spec cannot be parsed, include with 0 count
+                        specs.push({ name: entry.name, requirementCount: 0 });
+                    }
+                }
+            }
+        }
+        return specs;
+    }
+    displaySummary(changesData, specsData) {
+        const totalChanges = changesData.draft.length + changesData.active.length + changesData.completed.length;
+        const totalSpecs = specsData.length;
+        const totalRequirements = specsData.reduce((sum, spec) => sum + spec.requirementCount, 0);
+        // Calculate total task progress
+        let totalTasks = 0;
+        let completedTasks = 0;
+        changesData.active.forEach((change) => {
+            totalTasks += change.progress.total;
+            completedTasks += change.progress.completed;
+        });
+        changesData.completed.forEach(() => {
+            // Completed changes count as 100% done (we don't know exact task count)
+            // This is a simplification
+        });
+        console.log(chalk.bold('Summary:'));
+        console.log(`  ${chalk.cyan('●')} Specifications: ${chalk.bold(totalSpecs)} specs, ${chalk.bold(totalRequirements)} requirements`);
+        if (changesData.draft.length > 0) {
+            console.log(`  ${chalk.gray('●')} Draft Changes: ${chalk.bold(changesData.draft.length)}`);
+        }
+        console.log(`  ${chalk.yellow('●')} Active Changes: ${chalk.bold(changesData.active.length)} in progress`);
+        console.log(`  ${chalk.green('●')} Completed Changes: ${chalk.bold(changesData.completed.length)}`);
+        if (totalTasks > 0) {
+            const overallProgress = Math.round((completedTasks / totalTasks) * 100);
+            console.log(`  ${chalk.magenta('●')} Task Progress: ${chalk.bold(`${completedTasks}/${totalTasks}`)} (${overallProgress}% complete)`);
+        }
+    }
+    createProgressBar(completed, total, width = 20) {
+        if (total === 0)
+            return chalk.dim('─'.repeat(width));
+        const percentage = completed / total;
+        const filled = Math.round(percentage * width);
+        const empty = width - filled;
+        const filledBar = chalk.green('█'.repeat(filled));
+        const emptyBar = chalk.dim('░'.repeat(empty));
+        return `[${filledBar}${emptyBar}]`;
+    }
+}
+//# sourceMappingURL=view.js.map

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