gmc-openspec 1.1.0 → 1.4.2

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

@@ -1,10 +1,9 @@
 import { spawn as nodeSpawn } from 'node:child_process';
-import { WorkspaceLocalState, WorkspacePreferredOpener, WorkspaceSharedState, resolveWorkspaceOpenLinks } from '../../core/workspace/index.js';
+import { WorkspacePreferredOpener, WorkspaceViewState, WorkspaceOpenResolvedContext, WorkspaceOpenSurfaceGeneration, WorkspaceSkippedOpenLink } from '../../core/workspace/index.js';
 import { SelectedWorkspace } from './types.js';
 export declare const WORKSPACE_OPEN_MINIMAL_PROMPT = "Open this OpenSpec workspace.";
 export interface WorkspaceOpenState {
-    sharedState: WorkspaceSharedState;
-    localState: WorkspaceLocalState;
+    viewState: WorkspaceViewState;
     codeWorkspacePath: string;
 }
 export interface WorkspaceOpenLaunchCommand {
@@ -13,17 +12,26 @@ export interface WorkspaceOpenLaunchCommand {
     cwd: string;
     openerLabel: string;
 }
+export type WorkspaceOpenedRoot = {
+    kind: 'workspace' | 'initiative' | 'link';
+    name?: string;
+    path: string;
+};
+export interface WorkspaceOpenCommandBuildResult {
+    command: WorkspaceOpenLaunchCommand;
+    skipped: WorkspaceSkippedOpenLink[];
+    generated: WorkspaceOpenSurfaceGeneration;
+    openedRoots: WorkspaceOpenedRoot[];
+}
 export type WorkspaceOpenSpawn = typeof nodeSpawn;
 export interface WorkspaceOpenLaunchOptions {
     spawn?: WorkspaceOpenSpawn;
     isExecutableAvailable?: (executable: string) => boolean;
+    stdio?: 'inherit' | 'ignore';
 }
 export declare function readWorkspaceOpenState(selected: SelectedWorkspace): Promise<WorkspaceOpenState>;
-export declare function buildWorkspaceOpenLaunchCommand(opener: WorkspacePreferredOpener, workspaceRoot: string, codeWorkspacePath: string, linkedPaths: string[]): WorkspaceOpenLaunchCommand;
+export declare function buildWorkspaceOpenLaunchCommand(opener: WorkspacePreferredOpener, workspaceRoot: string, codeWorkspacePath: string, attachedPaths: string[]): WorkspaceOpenLaunchCommand;
 export declare function assertWorkspaceOpenerAvailable(opener: WorkspacePreferredOpener, codeWorkspacePath: string, isExecutableAvailable?: (executable: string) => boolean): void;
-export declare function buildWorkspaceOpenCommandForState(opener: WorkspacePreferredOpener, workspaceRoot: string, state: WorkspaceOpenState): Promise<{
-    command: WorkspaceOpenLaunchCommand;
-    skipped: Awaited<ReturnType<typeof resolveWorkspaceOpenLinks>>['skipped'];
-}>;
+export declare function buildWorkspaceOpenCommandForState(opener: WorkspacePreferredOpener, workspaceRoot: string, state: WorkspaceOpenState, resolvedContext?: WorkspaceOpenResolvedContext | null): Promise<WorkspaceOpenCommandBuildResult>;
 export declare function launchWorkspaceOpenCommand(command: WorkspaceOpenLaunchCommand, options?: WorkspaceOpenLaunchOptions): Promise<void>;
 //# sourceMappingURL=open.d.ts.map

package/dist/commands/workspace/open.js

@@ -1,19 +1,22 @@
 import { createRequire } from 'node:module';
-import { getWorkspaceCodeWorkspacePath, getWorkspaceOpenerExecutable, getWorkspaceOpenerLabel, isWorkspaceExecutableAvailable, readWorkspaceLocalState, readWorkspaceSharedState, resolveWorkspaceOpenLinks, writeWorkspaceCodeWorkspaceFile, } from '../../core/workspace/index.js';
+import { getWorkspaceCodeWorkspacePath, getWorkspaceOpenerExecutable, getWorkspaceOpenerLabel, isWorkspaceExecutableAvailable, readWorkspaceViewState, syncWorkspaceOpenSurface, } from '../../core/workspace/index.js';
 import { WorkspaceCliError, asErrorMessage } from './types.js';
 export const WORKSPACE_OPEN_MINIMAL_PROMPT = 'Open this OpenSpec workspace.';
+const CODEX_CLI_WRITABLE_ROOT_SANDBOX_ARGS = ['--sandbox', 'workspace-write'];
 const require = createRequire(import.meta.url);
 const spawn = require('cross-spawn');
+function isCodexCliOpener(opener) {
+    const openerId = opener.id;
+    return opener.kind === 'agent' && (openerId === 'codex-cli' || openerId === 'codex');
+}
 export async function readWorkspaceOpenState(selected) {
-    const sharedState = await readWorkspaceSharedState(selected.root);
-    const localState = await readWorkspaceLocalState(selected.root);
+    const viewState = await readWorkspaceViewState(selected.root);
     return {
-        sharedState,
-        localState,
-        codeWorkspacePath: getWorkspaceCodeWorkspacePath(selected.root, sharedState.name),
+        viewState,
+        codeWorkspacePath: getWorkspaceCodeWorkspacePath(selected.root, viewState.name),
     };
 }
-export function buildWorkspaceOpenLaunchCommand(opener, workspaceRoot, codeWorkspacePath, linkedPaths) {
+export function buildWorkspaceOpenLaunchCommand(opener, workspaceRoot, codeWorkspacePath, attachedPaths) {
     const executable = getWorkspaceOpenerExecutable(opener);
     const openerLabel = getWorkspaceOpenerLabel(opener);
     if (opener.kind === 'editor' || opener.id === 'github-copilot') {
@@ -27,7 +30,10 @@ export function buildWorkspaceOpenLaunchCommand(opener, workspaceRoot, codeWorks
     return {
         executable,
         args: [
-            ...linkedPaths.flatMap((linkedPath) => ['--add-dir', linkedPath]),
+            ...(isCodexCliOpener(opener) && attachedPaths.length > 0
+                ? CODEX_CLI_WRITABLE_ROOT_SANDBOX_ARGS
+                : []),
+            ...attachedPaths.flatMap((linkedPath) => ['--add-dir', linkedPath]),
             WORKSPACE_OPEN_MINIMAL_PROMPT,
         ],
         cwd: workspaceRoot,
@@ -48,12 +54,32 @@ export function assertWorkspaceOpenerAvailable(opener, codeWorkspacePath, isExec
         fix: `Install '${executable}' or choose another opener.`,
     });
 }
-export async function buildWorkspaceOpenCommandForState(opener, workspaceRoot, state) {
-    const openLinks = await resolveWorkspaceOpenLinks(state.sharedState, state.localState);
-    await writeWorkspaceCodeWorkspaceFile(state.codeWorkspacePath, openLinks.links);
+export async function buildWorkspaceOpenCommandForState(opener, workspaceRoot, state, resolvedContext) {
+    const openSurface = await syncWorkspaceOpenSurface(workspaceRoot, state.viewState, resolvedContext);
+    const openedRoots = [
+        { kind: 'workspace', path: workspaceRoot },
+        ...(resolvedContext
+            ? [
+                {
+                    kind: 'initiative',
+                    name: resolvedContext.initiative.id,
+                    path: resolvedContext.initiative.root,
+                },
+            ]
+            : []),
+        ...openSurface.links.map((link) => ({
+            kind: 'link',
+            name: link.name,
+            path: link.path,
+        })),
+    ];
     return {
-        command: buildWorkspaceOpenLaunchCommand(opener, workspaceRoot, state.codeWorkspacePath, openLinks.links.map((link) => link.path)),
-        skipped: openLinks.skipped,
+        command: buildWorkspaceOpenLaunchCommand(opener, workspaceRoot, state.codeWorkspacePath, openedRoots
+            .filter((root) => root.kind !== 'workspace')
+            .map((root) => root.path)),
+        skipped: openSurface.skipped,
+        generated: openSurface.generated,
+        openedRoots,
     };
 }
 export async function launchWorkspaceOpenCommand(command, options = {}) {
@@ -61,7 +87,7 @@ export async function launchWorkspaceOpenCommand(command, options = {}) {
     await new Promise((resolve, reject) => {
         const child = spawnCommand(command.executable, command.args, {
             cwd: command.cwd,
-            stdio: 'inherit',
+            stdio: options.stdio ?? 'inherit',
             shell: false,
         });
         child.on('error', (error) => {

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

@@ -0,0 +1,11 @@
+import { WorkspacePreferredOpener } from '../../core/workspace/index.js';
+import { WorkspaceOpenOptions } from './types.js';
+export declare function promptPreferredOpener(message: string, openerChoices?: import("../../core/workspace/openers.js").WorkspaceOpenerChoice[]): Promise<WorkspacePreferredOpener>;
+export declare function parseSetupOpenerOption(opener: string | undefined): WorkspacePreferredOpener | undefined;
+export declare function parseWorkspaceAgentOverride(agent: string): WorkspacePreferredOpener;
+export declare function getPreferredWorkspaceSkillAgentId(preferredOpener: WorkspacePreferredOpener | undefined): string | null;
+export declare function resolveWorkspaceOpenOpenerOverride(options: WorkspaceOpenOptions): WorkspacePreferredOpener | undefined;
+export declare function resolveWorkspaceOpenOpener(localState: {
+    preferred_opener?: WorkspacePreferredOpener;
+}, options: WorkspaceOpenOptions): Promise<WorkspacePreferredOpener>;
+//# sourceMappingURL=opener-selection.d.ts.map

package/dist/commands/workspace/opener-selection.js

@@ -0,0 +1,98 @@
+import { getDefaultWorkspaceOpenerChoiceValue, getWorkspaceSkillToolIds, listWorkspaceOpenerChoices, parseWorkspacePreferredOpenerValue, } from '../../core/workspace/index.js';
+import { isInteractive, resolveNoInteractive } from '../../utils/interactive.js';
+import { WorkspaceCliError, asErrorMessage } from './types.js';
+import { workspaceSelectTheme } from './prompt-theme.js';
+function formatOpenerChoiceName(choice) {
+    return choice.unavailableNote ? `${choice.label} (${choice.unavailableNote})` : choice.label;
+}
+export async function promptPreferredOpener(message, openerChoices = listWorkspaceOpenerChoices()) {
+    const { select } = await import('@inquirer/prompts');
+    const selectedValue = await select({
+        message,
+        default: getDefaultWorkspaceOpenerChoiceValue(openerChoices),
+        choices: openerChoices.map((choice) => ({
+            name: formatOpenerChoiceName(choice),
+            short: choice.label,
+            value: choice.value,
+            description: choice.unavailableNote ?? `Use ${choice.label}`,
+        })),
+        theme: workspaceSelectTheme,
+    });
+    return parseWorkspacePreferredOpenerValue(selectedValue);
+}
+export function parseSetupOpenerOption(opener) {
+    if (!opener) {
+        return undefined;
+    }
+    try {
+        return parseWorkspacePreferredOpenerValue(opener);
+    }
+    catch (error) {
+        throw new WorkspaceCliError(asErrorMessage(error), 'unsupported_workspace_opener', {
+            target: 'workspace.opener',
+            fix: 'Use --opener codex-cli, --opener claude, --opener github-copilot, or --opener editor.',
+        });
+    }
+}
+export function parseWorkspaceAgentOverride(agent) {
+    let opener = null;
+    try {
+        opener = parseWorkspacePreferredOpenerValue(agent);
+    }
+    catch {
+        opener = null;
+    }
+    if (!opener || opener.kind !== 'agent') {
+        throw new WorkspaceCliError(`Unsupported workspace agent '${agent}'. Supported agents: codex-cli, claude, github-copilot.`, 'unsupported_workspace_agent', {
+            target: 'workspace.opener',
+            fix: 'Use --agent codex-cli, --agent claude, or --agent github-copilot.',
+        });
+    }
+    return opener;
+}
+export function getPreferredWorkspaceSkillAgentId(preferredOpener) {
+    if (!preferredOpener || preferredOpener.kind !== 'agent') {
+        return null;
+    }
+    const toolId = preferredOpener.id === 'codex-cli' ? 'codex' : preferredOpener.id;
+    return getWorkspaceSkillToolIds().includes(toolId) ? toolId : null;
+}
+export function resolveWorkspaceOpenOpenerOverride(options) {
+    if (options.agent && options.editor) {
+        throw new WorkspaceCliError('workspace open accepts either --agent <tool> or --editor, not both.', 'workspace_opener_conflict', {
+            target: 'workspace.opener',
+            fix: 'Choose one opener override.',
+        });
+    }
+    if (options.agent) {
+        return parseWorkspaceAgentOverride(options.agent);
+    }
+    if (options.editor) {
+        return parseWorkspacePreferredOpenerValue('editor');
+    }
+    return undefined;
+}
+export async function resolveWorkspaceOpenOpener(localState, options) {
+    const override = resolveWorkspaceOpenOpenerOverride(options);
+    if (override) {
+        return override;
+    }
+    if (localState.preferred_opener) {
+        return localState.preferred_opener;
+    }
+    if (!resolveNoInteractive(options) && isInteractive(options)) {
+        const openerChoices = listWorkspaceOpenerChoices().filter((choice) => choice.available);
+        if (openerChoices.length === 0) {
+            throw new WorkspaceCliError('No supported workspace opener is available on PATH.', 'workspace_no_available_openers', {
+                target: 'workspace.opener',
+                fix: "Install VS Code ('code'), codex-cli ('codex'), or Claude ('claude'), then retry.",
+            });
+        }
+        return promptPreferredOpener('Open with:', openerChoices);
+    }
+    throw new WorkspaceCliError('This workspace does not have a preferred opener yet.', 'workspace_opener_unset', {
+        target: 'workspace.opener',
+        fix: 'Pass --agent <tool> or --editor, or run workspace setup interactively to choose a default opener.',
+    });
+}
+//# sourceMappingURL=opener-selection.js.map

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

@@ -1,23 +1,29 @@
-import { WorkspaceLocalState, WorkspacePreferredOpener, WorkspaceRegistryEntry, WorkspaceRegistryState, WorkspaceSharedState } from '../../core/workspace/index.js';
+import { WorkspacePreferredOpener, WorkspaceRegistryEntry, WorkspaceContextState, WorkspaceViewState } from '../../core/workspace/index.js';
 import { SelectedWorkspace, WorkspaceLinkMutationPayload, WorkspaceListOutput, WorkspaceOutput, WorkspaceStatus } from './types.js';
-export declare function readRegistry(): Promise<WorkspaceRegistryState>;
 export declare function directoryExists(dirPath: string): Promise<boolean>;
 export declare function resolveExistingDirectory(inputPath: string, cwd?: string): Promise<string>;
 export declare function inferLinkName(absolutePath: string): string;
 export declare function validateWorkspaceNameForSetup(name: string): string;
 export declare function validateLinkNameForCommand(name: string): string;
-export declare function createManagedWorkspace(name: string, links: Record<string, string>, preferredOpener?: WorkspacePreferredOpener): Promise<WorkspaceOutput>;
+export declare function createManagedWorkspace(name: string, links: Record<string, string>, preferredOpener?: WorkspacePreferredOpener, context?: WorkspaceContextState | null, tools?: string[]): Promise<WorkspaceOutput>;
 export declare function parseSetupLinks(linkInputs: string[] | undefined): Promise<Record<string, string>>;
 export declare function loadWorkspaceForList(entry: WorkspaceRegistryEntry): Promise<WorkspaceListOutput>;
 export declare function loadWorkspaceForDoctor(selected: SelectedWorkspace): Promise<{
     workspace: WorkspaceOutput;
     status: WorkspaceStatus[];
 }>;
-export declare function readWorkspaceForMutation(selected: SelectedWorkspace): Promise<{
-    sharedState: WorkspaceSharedState;
-    localState: WorkspaceLocalState;
-}>;
-export declare function recordSelectedWorkspaceAfterMutation(selected: SelectedWorkspace): Promise<void>;
+export declare function readWorkspaceForMutation(selected: SelectedWorkspace): Promise<WorkspaceViewState>;
 export declare function addWorkspaceLink(selected: SelectedWorkspace, nameOrPath: string, linkPath?: string): Promise<WorkspaceLinkMutationPayload>;
 export declare function updateWorkspaceLink(selected: SelectedWorkspace, linkNameInput: string, linkPath: string): Promise<WorkspaceLinkMutationPayload>;
+export declare function deriveWorkspaceNameForInitiative(initiativeId: string): string;
+export declare function selectOrCreateWorkspaceForInitiativeOpen(input: {
+    workspaceName?: string;
+    context: WorkspaceContextState;
+    preferredOpener?: WorkspacePreferredOpener;
+    linksForNewWorkspace?: () => Promise<Record<string, string>>;
+}): Promise<{
+    selected: SelectedWorkspace;
+    created: boolean;
+    state: WorkspaceViewState;
+}>;
 //# sourceMappingURL=operations.d.ts.map