gmc-openspec 1.0.0 → 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

@@ -1,4 +1,7 @@
+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 selectWorkspaceRootForCommand(workspaceRoot: string): Promise<SelectedWorkspace>;
 export declare function selectWorkspaceForCommand(options: WorkspaceSelectionOptions, commandName: string, selectionOptions?: {
     preferPositionalName?: boolean;

package/dist/commands/workspace/selection.js

@@ -1,7 +1,7 @@
-import { findWorkspaceRoot, listWorkspaceRegistryEntries, readWorkspaceSharedState, } from '../../core/workspace/index.js';
+import { findWorkspaceRoot, listKnownWorkspaceEntries, readWorkspaceViewState, } from '../../core/workspace/index.js';
 import { FileSystemUtils } from '../../utils/file-system.js';
 import { isInteractive, resolveNoInteractive } from '../../utils/interactive.js';
-import { readRegistry, validateWorkspaceNameForSetup } from './operations.js';
+import { validateWorkspaceNameForSetup } from './operations.js';
 import { WorkspaceCliError, makeStatus, } from './types.js';
 function normalizeRegistryRootForComparison(workspaceRoot) {
     try {
@@ -11,30 +11,41 @@ function normalizeRegistryRootForComparison(workspaceRoot) {
         return workspaceRoot;
     }
 }
-function workspaceNotInRegistryWarning() {
-    return makeStatus('warning', 'workspace_not_in_local_registry', 'This workspace is not recorded in the local workspace registry.', {
+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: 'Run a mutating workspace command from this workspace, such as workspace link or workspace relink, to record it locally.',
+        fix: 'Use openspec workspace list to inspect managed workspace views.',
     });
 }
-function isRegisteredWorkspaceRoot(registryRoot, currentWorkspaceRoot) {
-    return (registryRoot !== undefined &&
-        normalizeRegistryRootForComparison(registryRoot) ===
+function sameWorkspaceRoot(knownRoot, currentWorkspaceRoot) {
+    return (knownRoot !== undefined &&
+        normalizeRegistryRootForComparison(knownRoot) ===
             normalizeRegistryRootForComparison(currentWorkspaceRoot));
 }
-async function selectedWorkspaceFromRoot(currentWorkspaceRoot, registry) {
-    const sharedState = await readWorkspaceSharedState(currentWorkspaceRoot);
-    const registeredRoot = registry.workspaces[sharedState.name];
-    const isRegistered = isRegisteredWorkspaceRoot(registeredRoot, currentWorkspaceRoot);
+function findKnownWorkspaceByName(entries, workspaceName) {
+    return entries.find((entry) => entry.name === workspaceName);
+}
+export function selectedWorkspaceFromEntry(entry) {
     return {
-        name: sharedState.name,
+        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: isRegistered ? [] : [workspaceNotInRegistryWarning()],
-        unregisteredCurrentWorkspace: !isRegistered,
+        status: isKnown ? [] : [workspaceNotInKnownViewsWarning()],
+        unregisteredCurrentWorkspace: !isKnown,
     };
 }
 export async function selectWorkspaceRootForCommand(workspaceRoot) {
-    const registry = await readRegistry();
+    const entries = await listKnownWorkspaceEntries();
     const currentWorkspaceRoot = await findWorkspaceRoot(workspaceRoot);
     if (!currentWorkspaceRoot) {
         throw new WorkspaceCliError(`No OpenSpec workspace found at '${workspaceRoot}'.`, 'workspace_not_found', {
@@ -42,31 +53,25 @@ export async function selectWorkspaceRootForCommand(workspaceRoot) {
             fix: 'Pass a path inside an OpenSpec workspace.',
         });
     }
-    return selectedWorkspaceFromRoot(currentWorkspaceRoot, registry);
+    return selectedWorkspaceFromRoot(currentWorkspaceRoot, entries);
 }
 export async function selectWorkspaceForCommand(options, commandName, selectionOptions = {}) {
-    const registry = await readRegistry();
+    const entries = await listKnownWorkspaceEntries();
     if (options.workspace) {
         const workspaceName = validateWorkspaceNameForSetup(options.workspace);
-        const registryRoot = registry.workspaces[workspaceName];
-        if (!registryRoot) {
+        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 {
-            name: workspaceName,
-            root: registryRoot,
-            status: [],
-            unregisteredCurrentWorkspace: false,
-        };
+        return selectedWorkspaceFromEntry(entry);
     }
     const currentWorkspaceRoot = await findWorkspaceRoot(process.cwd());
     if (currentWorkspaceRoot) {
-        return selectedWorkspaceFromRoot(currentWorkspaceRoot, registry);
+        return selectedWorkspaceFromRoot(currentWorkspaceRoot, entries);
     }
-    const entries = listWorkspaceRegistryEntries(registry);
     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',
@@ -75,12 +80,7 @@ export async function selectWorkspaceForCommand(options, commandName, selectionO
     }
     if (entries.length === 1) {
         const [entry] = entries;
-        return {
-            name: entry.name,
-            root: entry.workspaceRoot,
-            status: [],
-            unregisteredCurrentWorkspace: false,
-        };
+        return selectedWorkspaceFromEntry(entry);
     }
     if (options.json || resolveNoInteractive(options) || !isInteractive(options)) {
         const knownNames = entries.map((entry) => entry.name).join(', ');
@@ -103,11 +103,13 @@ export async function selectWorkspaceForCommand(options, commandName, selectionO
             value: entry.name,
         })),
     });
-    return {
-        name: selectedName,
-        root: registry.workspaces[selectedName],
-        status: [],
-        unregisteredCurrentWorkspace: false,
-    };
+    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

@@ -1,3 +1,4 @@
+import type { ContextStoreSelector } from '../../core/context-store/index.js';
 export type StatusSeverity = 'error' | 'warning';
 export interface WorkspaceStatus {
     severity: StatusSeverity;
@@ -5,6 +6,7 @@ export interface WorkspaceStatus {
     message: string;
     target?: string;
     fix?: string;
+    details?: Record<string, unknown>;
 }
 export interface WorkspaceLinkOutput {
     name: string;
@@ -12,16 +14,24 @@ export interface WorkspaceLinkOutput {
     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[];
 }
@@ -50,6 +60,9 @@ export interface WorkspaceOpenOptions extends WorkspaceSelectionOptions {
     editor?: boolean;
     prepareOnly?: boolean;
     change?: string;
+    initiative?: string;
+    store?: string;
+    storePath?: string;
 }
 export interface WorkspaceListOptions {
     json?: boolean;
@@ -74,11 +87,13 @@ export declare class WorkspaceCliError extends Error {
     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;