@superkou/openspec 1.4.1

package/dist/commands/workspace/registration.js

@@ -0,0 +1,84 @@
+import { getWorkspaceSkillToolIds } from '../../core/workspace/index.js';
+function collectOption(value, previous) {
+    return [...previous, value];
+}
+function addWorkspaceSelectionOptions(command) {
+    return command
+        .option('--workspace <name>', 'Workspace name from known local workspace views')
+        .option('--json', 'Output as JSON')
+        .option('--no-interactive', 'Disable prompts');
+}
+export function registerWorkspaceCommandWith(program, workspaceCommand) {
+    const workspace = program
+        .command('workspace')
+        .description('Set up and inspect coordination workspaces');
+    workspace
+        .command('setup')
+        .description('Set up a workspace and link existing repos or folders')
+        .option('--name <name>', 'Workspace name')
+        .option('--link <link>', 'Repo or folder link. Use <path> or <name>=<path>.', collectOption, [])
+        .option('--opener <id>', 'Preferred opener: codex-cli, claude, github-copilot, or editor')
+        .option('--tools <tools>', `Install OpenSpec skills for agents. Use "all", "none", or a comma-separated list of: ${getWorkspaceSkillToolIds().join(', ')}`)
+        .option('--json', 'Output as JSON')
+        .option('--no-interactive', 'Disable prompts')
+        .action(async (options) => {
+        await workspaceCommand.setup(options);
+    });
+    workspace
+        .command('list')
+        .description('List known OpenSpec workspaces')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        await workspaceCommand.list(options);
+    });
+    workspace
+        .command('ls')
+        .description('List known OpenSpec workspaces')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        await workspaceCommand.list(options);
+    });
+    addWorkspaceSelectionOptions(workspace
+        .command('link [nameOrPath] [path]')
+        .description('Link an existing repo or folder to a workspace')).action(async (nameOrPath, linkPath, options) => {
+        await workspaceCommand.link(nameOrPath, linkPath, options);
+    });
+    addWorkspaceSelectionOptions(workspace
+        .command('relink <name> <path>')
+        .description('Update the local path for an existing workspace link')).action(async (linkName, linkPath, options) => {
+        await workspaceCommand.relink(linkName, linkPath, options);
+    });
+    addWorkspaceSelectionOptions(workspace
+        .command('doctor')
+        .description('Check what a workspace can resolve on this machine')).action(async (options) => {
+        await workspaceCommand.doctor(options);
+    });
+    workspace
+        .command('update [name]')
+        .description('Refresh workspace-local OpenSpec guidance and agent skills')
+        .option('--workspace <name>', 'Workspace name from known local workspace views')
+        .option('--tools <tools>', `Select agents for workspace skills. Use "all", "none", or a comma-separated list of: ${getWorkspaceSkillToolIds().join(', ')}. Global profile selects workflows; --tools selects agents.`)
+        .option('--json', 'Output as JSON')
+        .option('--no-interactive', 'Disable prompts')
+        .action(async (name, options) => {
+        await workspaceCommand.update(name, options);
+    });
+    workspace
+        .command('open [name]')
+        .description('Open a workspace in an agent or VS Code editor')
+        .option('--workspace <name>', 'Workspace name from known local workspace views')
+        .option('--initiative <id>', 'Open an initiative as a local workspace view')
+        .option('--store <id>', 'Context store id for --initiative')
+        .option('--store-path <path>', 'Existing local context store root for --initiative')
+        .option('--agent <tool>', 'Use an agent for this session: codex-cli, claude, or github-copilot')
+        .option('--editor', 'Open the workspace in VS Code editor mode')
+        .option('--prepare-only', 'Unsupported: preview surfaces belong to a future context/query command')
+        .option('--json', 'Output generated workspace view context as JSON after launch')
+        .option('--change <id>', 'Unsupported: change-scoped open belongs to future workspace change planning')
+        .option('--no-interactive', 'Disable prompts')
+        .action(async (name, options) => {
+        await workspaceCommand.open(name, options);
+    });
+    // Intentionally no public `workspace create` command in this slice.
+}
+//# sourceMappingURL=registration.js.map

package/dist/commands/workspace/selection.d.ts

@@ -0,0 +1,8 @@
+import { type WorkspaceRegistryEntry } from '../../core/workspace/index.js';
+import { SelectedWorkspace, WorkspaceSelectionOptions } from './types.js';
+export declare function selectedWorkspaceFromEntry(entry: WorkspaceRegistryEntry): SelectedWorkspace;
+export declare function selectedWorkspaceFromRoot(currentWorkspaceRoot: string, entries: WorkspaceRegistryEntry[]): Promise<SelectedWorkspace>;
+export declare function selectWorkspaceForCommand(options: WorkspaceSelectionOptions, commandName: string, selectionOptions?: {
+    preferPositionalName?: boolean;
+}): Promise<SelectedWorkspace>;
+//# sourceMappingURL=selection.d.ts.map

package/dist/commands/workspace/selection.js

@@ -0,0 +1,104 @@
+import { findWorkspaceRoot, listKnownWorkspaceEntries, readWorkspaceViewState, } from '../../core/workspace/index.js';
+import { FileSystemUtils } from '../../utils/file-system.js';
+import { isInteractive, resolveNoInteractive } from '../../utils/interactive.js';
+import { validateWorkspaceNameForSetup } from './operations.js';
+import { WorkspaceCliError, makeStatus, } from './types.js';
+function normalizeRegistryRootForComparison(workspaceRoot) {
+    try {
+        return FileSystemUtils.canonicalizeExistingPath(workspaceRoot);
+    }
+    catch {
+        return workspaceRoot;
+    }
+}
+function workspaceNotInKnownViewsWarning() {
+    return makeStatus('warning', 'workspace_not_in_known_views', 'This workspace is not in the managed local workspace views list.', {
+        target: 'workspace.root',
+        fix: 'Use openspec workspace list to inspect managed workspace views.',
+    });
+}
+function sameWorkspaceRoot(knownRoot, currentWorkspaceRoot) {
+    return (knownRoot !== undefined &&
+        normalizeRegistryRootForComparison(knownRoot) ===
+            normalizeRegistryRootForComparison(currentWorkspaceRoot));
+}
+function findKnownWorkspaceByName(entries, workspaceName) {
+    return entries.find((entry) => entry.name === workspaceName);
+}
+export function selectedWorkspaceFromEntry(entry) {
+    return {
+        name: entry.name,
+        root: entry.workspaceRoot,
+        status: [],
+        unregisteredCurrentWorkspace: false,
+    };
+}
+export async function selectedWorkspaceFromRoot(currentWorkspaceRoot, entries) {
+    const viewState = await readWorkspaceViewState(currentWorkspaceRoot);
+    const knownRoot = findKnownWorkspaceByName(entries, viewState.name)?.workspaceRoot;
+    const isKnown = sameWorkspaceRoot(knownRoot, currentWorkspaceRoot);
+    return {
+        name: viewState.name,
+        root: currentWorkspaceRoot,
+        status: isKnown ? [] : [workspaceNotInKnownViewsWarning()],
+        unregisteredCurrentWorkspace: !isKnown,
+    };
+}
+export async function selectWorkspaceForCommand(options, commandName, selectionOptions = {}) {
+    const entries = await listKnownWorkspaceEntries();
+    if (options.workspace) {
+        const workspaceName = validateWorkspaceNameForSetup(options.workspace);
+        const entry = findKnownWorkspaceByName(entries, workspaceName);
+        if (!entry) {
+            throw new WorkspaceCliError(`Unknown OpenSpec workspace '${workspaceName}'.`, 'workspace_not_found', {
+                target: 'workspace.name',
+                fix: 'Run openspec workspace list to see known workspaces.',
+            });
+        }
+        return selectedWorkspaceFromEntry(entry);
+    }
+    const currentWorkspaceRoot = await findWorkspaceRoot(process.cwd());
+    if (currentWorkspaceRoot) {
+        return selectedWorkspaceFromRoot(currentWorkspaceRoot, entries);
+    }
+    if (entries.length === 0) {
+        throw new WorkspaceCliError("No known OpenSpec workspaces. Run 'openspec workspace setup' first.\nAfter at least one workspace is known locally, you can also pass --workspace <name>.", 'no_known_workspaces', {
+            target: 'workspace.name',
+            fix: 'openspec workspace setup',
+        });
+    }
+    if (entries.length === 1) {
+        const [entry] = entries;
+        return selectedWorkspaceFromEntry(entry);
+    }
+    if (options.json || resolveNoInteractive(options) || !isInteractive(options)) {
+        const knownNames = entries.map((entry) => entry.name).join(', ');
+        const usesPositionalName = selectionOptions.preferPositionalName;
+        const fix = usesPositionalName
+            ? `openspec workspace ${commandName} <name>`
+            : `openspec workspace ${commandName} --workspace <name>`;
+        throw new WorkspaceCliError(usesPositionalName
+            ? `Multiple OpenSpec workspaces are known. Known workspaces: ${knownNames}. Pass a workspace name.`
+            : `Multiple OpenSpec workspaces are known. Known workspaces: ${knownNames}. Pass --workspace <name>.`, 'workspace_selection_ambiguous', {
+            target: 'workspace.name',
+            fix,
+        });
+    }
+    const { select } = await import('@inquirer/prompts');
+    const selectedName = await select({
+        message: 'Select workspace:',
+        choices: entries.map((entry) => ({
+            name: `${entry.name} (${entry.workspaceRoot})`,
+            value: entry.name,
+        })),
+    });
+    const selectedEntry = findKnownWorkspaceByName(entries, selectedName);
+    if (!selectedEntry) {
+        throw new WorkspaceCliError(`Unknown OpenSpec workspace '${selectedName}'.`, 'workspace_not_found', {
+            target: 'workspace.name',
+            fix: 'Run openspec workspace list to see known workspaces.',
+        });
+    }
+    return selectedWorkspaceFromEntry(selectedEntry);
+}
+//# sourceMappingURL=selection.js.map

package/dist/commands/workspace/setup-prompts.d.ts

@@ -0,0 +1,13 @@
+export interface PromptSetupLinksOptions {
+    heading?: string;
+    intro?: string;
+    allowEmpty?: boolean;
+    emptyName?: string;
+    emptyShort?: string;
+    emptyDescription?: string;
+    finishName?: string;
+    finishShort?: string;
+    finishDescription?: string;
+}
+export declare function promptSetupLinks(options?: PromptSetupLinksOptions): Promise<Record<string, string>>;
+//# sourceMappingURL=setup-prompts.d.ts.map

package/dist/commands/workspace/setup-prompts.js

@@ -0,0 +1,121 @@
+import chalk from 'chalk';
+import * as nodeFs from 'node:fs';
+import * as path from 'node:path';
+import { inferLinkName, resolveExistingDirectory, validateLinkNameForCommand, } from './operations.js';
+import { workspacePromptTheme, workspaceSelectTheme } from './prompt-theme.js';
+import { asErrorMessage } from './types.js';
+const fs = nodeFs;
+async function promptExistingPath(message, defaultPath) {
+    const { input } = await import('@inquirer/prompts');
+    const pathInput = await input({
+        message,
+        default: defaultPath,
+        prefill: defaultPath ? 'editable' : undefined,
+        required: true,
+        theme: workspacePromptTheme,
+        validate(value) {
+            const resolvedPath = path.isAbsolute(value)
+                ? path.resolve(value)
+                : path.resolve(process.cwd(), value);
+            return fs.existsSync(resolvedPath) && fs.statSync(resolvedPath).isDirectory()
+                ? true
+                : 'Enter an existing repo or folder path.';
+        },
+    });
+    return resolveExistingDirectory(pathInput);
+}
+async function promptLinkName(existingLinks) {
+    const { input } = await import('@inquirer/prompts');
+    return input({
+        message: 'Link name:',
+        required: true,
+        theme: workspacePromptTheme,
+        validate(value) {
+            try {
+                validateLinkNameForCommand(value);
+            }
+            catch (error) {
+                return asErrorMessage(error);
+            }
+            if (existingLinks[value]) {
+                return `Link name '${value}' is already linked to ${existingLinks[value]}.`;
+            }
+            return true;
+        },
+    });
+}
+export async function promptSetupLinks(options = {}) {
+    const { select } = await import('@inquirer/prompts');
+    const links = {};
+    const heading = options.heading ?? '[2/5] Link repos or folders';
+    const intro = options.intro ?? 'Start with the current directory, or enter another repo path.';
+    console.log('');
+    console.log(chalk.bold(heading));
+    console.log(chalk.dim(intro));
+    console.log('');
+    while (true) {
+        const linkCount = Object.keys(links).length;
+        if (linkCount === 0 && options.allowEmpty) {
+            const firstAction = await select({
+                message: 'Continue',
+                default: 'finish',
+                choices: [
+                    {
+                        name: options.emptyName ?? options.finishName ?? 'Create workspace files',
+                        short: options.emptyShort ?? options.finishShort ?? 'Create workspace files',
+                        value: 'finish',
+                        description: options.emptyDescription ?? 'Create the workspace without linked repos or folders',
+                    },
+                    {
+                        name: 'Add a repo or folder',
+                        short: 'Add repo',
+                        value: 'add',
+                        description: 'Include local implementation context in this workspace',
+                    },
+                ],
+                theme: workspaceSelectTheme,
+            });
+            if (firstAction === 'finish') {
+                return links;
+            }
+        }
+        const resolvedPath = await promptExistingPath(linkCount === 0 ? 'Repo or folder path:' : 'Another repo or folder path:', linkCount === 0 ? '.' : undefined);
+        let linkName = inferLinkName(resolvedPath);
+        try {
+            validateLinkNameForCommand(linkName);
+        }
+        catch {
+            linkName = await promptLinkName(links);
+        }
+        if (links[linkName]) {
+            console.log(`Link name '${linkName}' is already linked to ${links[linkName]}.`);
+            linkName = await promptLinkName(links);
+        }
+        links[linkName] = resolvedPath;
+        console.log(chalk.green(`Added link '${linkName}'`));
+        console.log(chalk.dim(`  ${resolvedPath}`));
+        const nextAction = await select({
+            message: 'Continue',
+            default: 'finish',
+            choices: [
+                {
+                    name: options.finishName ?? 'Create workspace files',
+                    short: options.finishShort ?? 'Create workspace files',
+                    value: 'finish',
+                    description: options.finishDescription ?? 'Run a workspace check after setup',
+                },
+                {
+                    name: 'Add another repo or folder',
+                    short: 'Add another',
+                    value: 'add',
+                    description: 'Include another local directory in this workspace',
+                },
+            ],
+            theme: workspaceSelectTheme,
+        });
+        if (nextAction === 'finish') {
+            return links;
+        }
+    }
+}
+//# sourceMappingURL=setup-prompts.js.map

package/dist/commands/workspace/types.d.ts

@@ -0,0 +1,103 @@
+import type { ContextStoreSelector } from '../../core/context-store/index.js';
+export type StatusSeverity = 'error' | 'warning';
+export interface WorkspaceStatus {
+    severity: StatusSeverity;
+    code: string;
+    message: string;
+    target?: string;
+    fix?: string;
+    details?: Record<string, unknown>;
+}
+export interface WorkspaceLinkOutput {
+    name: string;
+    path: string | null;
+    repo_specs_path?: string | null;
+    status: WorkspaceStatus[];
+}
+export interface WorkspaceContextOutput {
+    store: string;
+    initiative: string;
+    store_selector: ContextStoreSelector;
+}
+export interface WorkspaceOutput {
+    name: string;
+    root: string;
+    planning_path: string;
+    state_path?: string;
+    context?: WorkspaceContextOutput | null;
+    links: WorkspaceLinkOutput[];
+    status: WorkspaceStatus[];
+}
+export interface WorkspaceListOutput {
+    name: string;
+    root: string;
+    context?: WorkspaceContextOutput | null;
+    links: WorkspaceLinkOutput[];
+    status: WorkspaceStatus[];
+}
+export interface WorkspaceSetupOptions {
+    name?: string;
+    link?: string[];
+    opener?: string;
+    tools?: string;
+    json?: boolean;
+    noInteractive?: boolean;
+    interactive?: boolean;
+}
+export interface WorkspaceSelectionOptions {
+    workspace?: string;
+    json?: boolean;
+    noInteractive?: boolean;
+    interactive?: boolean;
+}
+export type WorkspaceLinkOptions = WorkspaceSelectionOptions;
+export interface WorkspaceUpdateOptions extends WorkspaceSelectionOptions {
+    tools?: string;
+    force?: boolean;
+}
+export interface WorkspaceOpenOptions extends WorkspaceSelectionOptions {
+    agent?: string;
+    editor?: boolean;
+    prepareOnly?: boolean;
+    change?: string;
+    initiative?: string;
+    store?: string;
+    storePath?: string;
+}
+export interface WorkspaceListOptions {
+    json?: boolean;
+}
+export interface SelectedWorkspace {
+    name: string;
+    root: string;
+    status: WorkspaceStatus[];
+    unregisteredCurrentWorkspace: boolean;
+}
+export interface WorkspaceLinkMutationPayload {
+    workspace: WorkspaceOutput;
+    link: {
+        name: string;
+        path: string;
+        status: WorkspaceStatus[];
+    };
+    status: WorkspaceStatus[];
+}
+export declare class WorkspaceCliError extends Error {
+    readonly status: WorkspaceStatus;
+    constructor(message: string, code: string, options?: {
+        target?: string;
+        fix?: string;
+        details?: Record<string, unknown>;
+    });
+}
+export declare function makeStatus(severity: StatusSeverity, code: string, message: string, options?: {
+    target?: string;
+    fix?: string;
+    details?: Record<string, unknown>;
+}): WorkspaceStatus;
+export declare function asErrorMessage(error: unknown): string;
+export declare function asStatus(error: unknown): WorkspaceStatus;
+export declare function appendStatus<T extends {
+    status: WorkspaceStatus[];
+}>(payload: T, status: WorkspaceStatus): T;
+//# sourceMappingURL=types.d.ts.map

package/dist/commands/workspace/types.js

@@ -0,0 +1,36 @@
+export class WorkspaceCliError extends Error {
+    status;
+    constructor(message, code, options = {}) {
+        super(message);
+        this.status = {
+            severity: 'error',
+            code,
+            message,
+            ...options,
+        };
+    }
+}
+export function makeStatus(severity, code, message, options = {}) {
+    return {
+        severity,
+        code,
+        message,
+        ...options,
+    };
+}
+export function asErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function asStatus(error) {
+    if (error instanceof WorkspaceCliError) {
+        return error.status;
+    }
+    return makeStatus('error', 'workspace_error', asErrorMessage(error));
+}
+export function appendStatus(payload, status) {
+    return {
+        ...payload,
+        status: [...payload.status, status],
+    };
+}
+//# sourceMappingURL=types.js.map

package/dist/commands/workspace.d.ts

@@ -0,0 +1,5 @@
+import { Command } from 'commander';
+import { WorkspaceUpdateOptions } from './workspace/types.js';
+export declare function runWorkspaceUpdate(positionalName: string | undefined, options?: WorkspaceUpdateOptions): Promise<void>;
+export declare function registerWorkspaceCommand(program: Command): void;
+//# sourceMappingURL=workspace.d.ts.map