@fission-ai/openspec 1.3.1 → 1.4.0

package/dist/core/workspace/legacy-state.js

@@ -0,0 +1,200 @@
+import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
+import { z } from 'zod';
+import { WORKSPACE_METADATA_DIR_NAME, WORKSPACE_VIEW_STATE_FILE_NAME, getWorkspaceMetadataDir, parseWorkspaceViewState, validateWorkspaceLinkName, validateWorkspaceName, validateWorkspacePreferredOpener, } from './foundation.js';
+import { FileSystemUtils } from '../../utils/file-system.js';
+export const WORKSPACE_LEGACY_SHARED_STATE_FILE_NAME = WORKSPACE_VIEW_STATE_FILE_NAME;
+export const WORKSPACE_LEGACY_LOCAL_STATE_FILE_NAME = 'local.yaml';
+export const WORKSPACE_LEGACY_LOCAL_STATE_IGNORE_PATTERN = `${WORKSPACE_METADATA_DIR_NAME}/${WORKSPACE_LEGACY_LOCAL_STATE_FILE_NAME}`;
+function joinWorkspacePath(basePath, ...segments) {
+    return FileSystemUtils.joinPath(basePath, ...segments);
+}
+export function getWorkspaceLegacySharedStatePath(workspaceRoot) {
+    return joinWorkspacePath(getWorkspaceMetadataDir(workspaceRoot), WORKSPACE_LEGACY_SHARED_STATE_FILE_NAME);
+}
+export function getWorkspaceLegacyLocalStatePath(workspaceRoot) {
+    return joinWorkspacePath(getWorkspaceMetadataDir(workspaceRoot), WORKSPACE_LEGACY_LOCAL_STATE_FILE_NAME);
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+const PlainObjectSchema = z.custom(isPlainObject, {
+    message: 'must be an object',
+});
+const PreferredOpenerSchema = z
+    .object({
+    kind: z.enum(['agent', 'editor']),
+    id: z.string(),
+})
+    .strict();
+const WorkspaceSkillStateSchema = z
+    .object({
+    selected_agents: z.array(z.string()),
+    last_applied_profile: z.enum(['core', 'custom']).optional(),
+    last_applied_delivery: z.enum(['both', 'skills', 'commands']).optional(),
+    last_applied_workflow_ids: z.array(z.string()).optional(),
+    last_applied_at: z.string().optional(),
+})
+    .strict();
+const SharedStateSchema = z.object({
+    version: z.literal(1),
+    name: z.string(),
+    context: z.unknown().optional(),
+    links: z.record(z.string(), PlainObjectSchema),
+}).strict();
+const LocalStateSchema = z.object({
+    version: z.literal(1),
+    paths: z.record(z.string(), z.string()),
+    preferred_opener: PreferredOpenerSchema.optional(),
+    tools: z.array(z.string()).optional(),
+    workspace_skills: WorkspaceSkillStateSchema.optional(),
+}).strict();
+function formatZodIssues(error) {
+    return error.issues
+        .map((issue) => {
+        const location = issue.path.length > 0 ? issue.path.join('.') : 'root';
+        return `${location}: ${issue.message}`;
+    })
+        .join('; ');
+}
+function parseYamlObject(content, label) {
+    try {
+        return parseYaml(content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid ${label}: ${message}`);
+    }
+}
+function assertValidMapKeys(keys, validator, label) {
+    for (const key of keys) {
+        try {
+            validator(key);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Invalid ${label} '${key}': ${message}`);
+        }
+    }
+}
+function normalizeLegacyWorkspaceContext(name, context) {
+    return parseWorkspaceViewState(stringifyYaml({
+        version: 1,
+        name,
+        context: context ?? null,
+        links: {},
+    })).context;
+}
+export function workspaceViewToSharedState(state) {
+    return {
+        version: 1,
+        name: state.name,
+        context: state.context,
+        links: Object.fromEntries(Object.keys(state.links).map((linkName) => [linkName, {}])),
+    };
+}
+export function workspaceViewToLocalState(state) {
+    return {
+        version: 1,
+        paths: Object.fromEntries(Object.entries(state.links).filter((entry) => typeof entry[1] === 'string')),
+        ...(state.preferred_opener ? { preferred_opener: state.preferred_opener } : {}),
+        ...(state.tools ? { tools: state.tools } : {}),
+        ...(state.workspace_skills ? { workspace_skills: state.workspace_skills } : {}),
+    };
+}
+export function workspaceStatePartsToViewState(sharedState, localState) {
+    const linkNames = new Set([
+        ...Object.keys(sharedState.links),
+        ...Object.keys(localState?.paths ?? {}),
+    ]);
+    const links = Object.fromEntries([...linkNames]
+        .sort((a, b) => a.localeCompare(b))
+        .map((linkName) => [linkName, localState?.paths[linkName] ?? null]));
+    return {
+        version: 1,
+        name: sharedState.name,
+        context: sharedState.context,
+        links,
+        ...(localState?.preferred_opener ? { preferred_opener: localState.preferred_opener } : {}),
+        ...(localState?.tools ? { tools: localState.tools } : {}),
+        ...(localState?.workspace_skills ? { workspace_skills: localState.workspace_skills } : {}),
+    };
+}
+export function parseWorkspaceSharedState(content) {
+    const raw = parseYamlObject(content, 'workspace shared state');
+    try {
+        return workspaceViewToSharedState(parseWorkspaceViewState(content));
+    }
+    catch {
+        // Fall through to the legacy shared schema.
+    }
+    const result = SharedStateSchema.safeParse(raw);
+    if (!result.success) {
+        throw new Error(`Invalid workspace shared state: ${formatZodIssues(result.error)}`);
+    }
+    validateWorkspaceName(result.data.name);
+    assertValidMapKeys(Object.keys(result.data.links), validateWorkspaceLinkName, 'workspace link name');
+    return {
+        version: 1,
+        name: result.data.name,
+        context: normalizeLegacyWorkspaceContext(result.data.name, result.data.context),
+        links: result.data.links,
+    };
+}
+export function parseWorkspaceLocalState(content) {
+    const raw = parseYamlObject(content, 'workspace local state');
+    try {
+        return workspaceViewToLocalState(parseWorkspaceViewState(content));
+    }
+    catch {
+        // Fall through to the legacy local schema.
+    }
+    const result = LocalStateSchema.safeParse(raw);
+    if (!result.success) {
+        throw new Error(`Invalid workspace local state: ${formatZodIssues(result.error)}`);
+    }
+    assertValidMapKeys(Object.keys(result.data.paths), validateWorkspaceLinkName, 'workspace local path name');
+    const preferredOpener = result.data.preferred_opener
+        ? validateWorkspacePreferredOpener(result.data.preferred_opener)
+        : undefined;
+    return {
+        version: 1,
+        paths: result.data.paths,
+        ...(preferredOpener ? { preferred_opener: preferredOpener } : {}),
+        ...(result.data.tools ? { tools: result.data.tools } : {}),
+        ...(result.data.workspace_skills ? { workspace_skills: result.data.workspace_skills } : {}),
+    };
+}
+export function serializeWorkspaceSharedState(state) {
+    validateWorkspaceName(state.name);
+    assertValidMapKeys(Object.keys(state.links), validateWorkspaceLinkName, 'workspace link name');
+    for (const [linkName, linkState] of Object.entries(state.links)) {
+        if (!isPlainObject(linkState)) {
+            throw new Error(`Invalid workspace link '${linkName}': link state must be an object`);
+        }
+    }
+    return stringifyYaml({
+        version: 1,
+        name: state.name,
+        context: state.context,
+        links: state.links,
+    });
+}
+export function serializeWorkspaceLocalState(state) {
+    assertValidMapKeys(Object.keys(state.paths), validateWorkspaceLinkName, 'workspace local path name');
+    for (const [linkName, localPath] of Object.entries(state.paths)) {
+        if (typeof localPath !== 'string') {
+            throw new Error(`Invalid workspace local path '${linkName}': path must be a string`);
+        }
+    }
+    const preferredOpener = state.preferred_opener
+        ? validateWorkspacePreferredOpener(state.preferred_opener)
+        : undefined;
+    return stringifyYaml({
+        version: 1,
+        paths: state.paths,
+        ...(preferredOpener ? { preferred_opener: preferredOpener } : {}),
+        ...(state.tools ? { tools: state.tools } : {}),
+        ...(state.workspace_skills ? { workspace_skills: state.workspace_skills } : {}),
+    });
+}
+//# sourceMappingURL=legacy-state.js.map

package/dist/core/workspace/link-input.d.ts

@@ -0,0 +1,9 @@
+export interface WorkspaceParsedLinkInput {
+    name?: string;
+    pathInput: string;
+}
+export interface WorkspaceLinkInputParseOptions {
+    cwd?: string;
+}
+export declare function parseWorkspaceSetupLinkInput(value: string, options?: WorkspaceLinkInputParseOptions): Promise<WorkspaceParsedLinkInput>;
+//# sourceMappingURL=link-input.d.ts.map

package/dist/core/workspace/link-input.js

@@ -0,0 +1,32 @@
+import * as nodeFs from 'node:fs';
+import * as path from 'node:path';
+const fs = nodeFs.promises;
+async function directoryExists(inputPath, cwd) {
+    if (inputPath.length === 0) {
+        return false;
+    }
+    const resolvedPath = path.isAbsolute(inputPath)
+        ? path.resolve(inputPath)
+        : path.resolve(cwd, inputPath);
+    try {
+        return (await fs.stat(resolvedPath)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+export async function parseWorkspaceSetupLinkInput(value, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    if (await directoryExists(value, cwd)) {
+        return { pathInput: value };
+    }
+    const separatorIndex = value.indexOf('=');
+    if (separatorIndex === -1) {
+        return { pathInput: value };
+    }
+    return {
+        name: value.slice(0, separatorIndex),
+        pathInput: value.slice(separatorIndex + 1),
+    };
+}
+//# sourceMappingURL=link-input.js.map

package/dist/core/workspace/open-surface.d.ts

@@ -0,0 +1,45 @@
+import { WorkspaceViewState } from './foundation.js';
+export declare const WORKSPACE_GUIDANCE_START_MARKER = "<!-- OPENSPEC:WORKSPACE-GUIDANCE:START -->";
+export declare const WORKSPACE_GUIDANCE_END_MARKER = "<!-- OPENSPEC:WORKSPACE-GUIDANCE:END -->";
+export declare const WORKSPACE_OPEN_ROOT_FOLDER_LABEL = "OpenSpec workspace";
+export declare const WORKSPACE_OPEN_INITIATIVE_FOLDER_LABEL = "Initiative context";
+export declare const WORKSPACE_GUIDANCE_BODY = "# OpenSpec Workspace Guidance\n\nThis directory is an OpenSpec workspace: a local working view over context stores, initiatives, repos, and folders.\n\n- Use this workspace to open the local view of coordinated work.\n- Use initiatives for durable cross-team or cross-repo intent, decisions, requirements, and coordination context.\n- Use repo-local OpenSpec changes for implementation plans owned by a repo or team.\n- Use linked repos and folders to inspect context, understand ownership, and make edits in the place that owns the work.\n- Keep workspace-local files focused on local paths, opener state, agent setup, and other machine-specific view state.\n- Use OpenSpec workspace commands instead of hand-editing `workspace.yaml`.\n- If this workspace contains legacy or beta workspace-level planning files, treat them as compatibility context unless the user explicitly asks to use that beta flow.";
+export interface WorkspaceOpenResolvedContext {
+    contextStore: {
+        id: string;
+        root: string;
+    };
+    initiative: {
+        id: string;
+        title: string;
+        root: string;
+        metadataPath: string;
+        storePath: string;
+    };
+}
+export interface WorkspaceOpenLink {
+    name: string;
+    path: string;
+}
+export interface WorkspaceSkippedOpenLink {
+    name: string;
+    path: string | null;
+    reason: 'missing-local-path' | 'path-missing';
+}
+export interface WorkspaceOpenSurfaceLinks {
+    links: WorkspaceOpenLink[];
+    skipped: WorkspaceSkippedOpenLink[];
+}
+export interface WorkspaceOpenSurfaceGeneration {
+    agentsPath: string;
+    codeWorkspacePath: string;
+}
+export declare function buildWorkspaceGuidanceBlock(viewState?: WorkspaceViewState, resolvedContext?: WorkspaceOpenResolvedContext | null): string;
+export declare function applyWorkspaceGuidanceBlock(existingContent: string, viewState?: WorkspaceViewState, resolvedContext?: WorkspaceOpenResolvedContext | null): string;
+export declare function buildWorkspaceCodeWorkspaceContent(links: WorkspaceOpenLink[], resolvedContext?: WorkspaceOpenResolvedContext | null): string;
+export declare function writeWorkspaceCodeWorkspaceFile(codeWorkspacePath: string, links: WorkspaceOpenLink[], resolvedContext?: WorkspaceOpenResolvedContext | null): Promise<void>;
+export declare function resolveWorkspaceOpenLinks(viewState: WorkspaceViewState): Promise<WorkspaceOpenSurfaceLinks>;
+export declare function syncWorkspaceOpenSurface(workspaceRoot: string, viewState: WorkspaceViewState, resolvedContext?: WorkspaceOpenResolvedContext | null): Promise<WorkspaceOpenSurfaceLinks & {
+    generated: WorkspaceOpenSurfaceGeneration;
+}>;
+//# sourceMappingURL=open-surface.d.ts.map

package/dist/core/workspace/open-surface.js

@@ -0,0 +1,215 @@
+import * as nodeFs from 'node:fs';
+import * as path from 'node:path';
+import { FileSystemUtils } from '../../utils/file-system.js';
+import { getWorkspaceContextInitiativeId, getWorkspaceCodeWorkspacePath, getWorkspaceCodeWorkspaceFileName, } from './foundation.js';
+const fs = nodeFs.promises;
+export const WORKSPACE_GUIDANCE_START_MARKER = '<!-- OPENSPEC:WORKSPACE-GUIDANCE:START -->';
+export const WORKSPACE_GUIDANCE_END_MARKER = '<!-- OPENSPEC:WORKSPACE-GUIDANCE:END -->';
+export const WORKSPACE_OPEN_ROOT_FOLDER_LABEL = 'OpenSpec workspace';
+export const WORKSPACE_OPEN_INITIATIVE_FOLDER_LABEL = 'Initiative context';
+export const WORKSPACE_GUIDANCE_BODY = `# OpenSpec Workspace Guidance
+
+This directory is an OpenSpec workspace: a local working view over context stores, initiatives, repos, and folders.
+
+- Use this workspace to open the local view of coordinated work.
+- Use initiatives for durable cross-team or cross-repo intent, decisions, requirements, and coordination context.
+- Use repo-local OpenSpec changes for implementation plans owned by a repo or team.
+- Use linked repos and folders to inspect context, understand ownership, and make edits in the place that owns the work.
+- Keep workspace-local files focused on local paths, opener state, agent setup, and other machine-specific view state.
+- Use OpenSpec workspace commands instead of hand-editing \`workspace.yaml\`.
+- If this workspace contains legacy or beta workspace-level planning files, treat them as compatibility context unless the user explicitly asks to use that beta flow.`;
+async function fileExists(filePath) {
+    try {
+        return (await fs.stat(filePath)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function directoryExists(dirPath) {
+    try {
+        return (await fs.stat(dirPath)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function formatGuidancePathList(items) {
+    if (items.length === 0) {
+        return '- None selected yet.';
+    }
+    return items.map((item) => `- ${item.label}: ${item.path}`).join('\n');
+}
+function buildWorkspaceContextGuidance(viewState, resolvedContext) {
+    const linkedRoots = Object.entries(viewState.links)
+        .filter((entry) => typeof entry[1] === 'string')
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([name, linkPath]) => ({ label: name, path: linkPath }));
+    if (!viewState.context) {
+        return `## Local View
+
+This workspace is not bound to an initiative. It is still a first-class local view over selected repos or folders.
+
+## Linked Implementation Context
+
+${formatGuidancePathList(linkedRoots)}`;
+    }
+    const storedContextSelector = viewState.context.store.selector;
+    const storedContextStore = viewState.context
+        ? storedContextSelector?.kind === 'path'
+            ? `${viewState.context.store.id} via ${storedContextSelector.path}`
+            : viewState.context.store.id
+        : null;
+    const storedInitiativeId = viewState.context
+        ? getWorkspaceContextInitiativeId(viewState.context)
+        : null;
+    const contextLines = resolvedContext
+        ? [
+            `- Context store: ${resolvedContext.contextStore.id} (${resolvedContext.contextStore.root})`,
+            `- Initiative: ${resolvedContext.initiative.id} (${resolvedContext.initiative.root})`,
+            `- Initiative title: ${resolvedContext.initiative.title}`,
+            `- Initiative metadata: ${resolvedContext.initiative.metadataPath}`,
+            '- Broader context may exist in the context store, but this workspace opens the selected initiative by default.',
+        ].join('\n')
+        : [
+            `- Context store: ${storedContextStore}`,
+            `- Initiative: ${storedInitiativeId}`,
+            '- Run `openspec workspace open --json` to refresh resolved local paths for this view.',
+        ].join('\n');
+    return `## Selected Initiative Context
+
+${contextLines}
+
+## Advisory Edit Boundaries
+
+- Treat initiative and context-store files as shared coordination context.
+- Treat linked repos and folders as local implementation context when the user has selected them.
+- These boundaries are advisory in this OpenSpec version; use judgment and repo ownership when editing.
+
+## Linked Implementation Context
+
+${formatGuidancePathList(linkedRoots)}`;
+}
+export function buildWorkspaceGuidanceBlock(viewState, resolvedContext) {
+    const contextGuidance = viewState
+        ? `\n\n${buildWorkspaceContextGuidance(viewState, resolvedContext)}`
+        : '';
+    return `${WORKSPACE_GUIDANCE_START_MARKER}
+${WORKSPACE_GUIDANCE_BODY}${contextGuidance}
+${WORKSPACE_GUIDANCE_END_MARKER}`;
+}
+export function applyWorkspaceGuidanceBlock(existingContent, viewState, resolvedContext) {
+    const block = buildWorkspaceGuidanceBlock(viewState, resolvedContext);
+    const startIndex = existingContent.indexOf(WORKSPACE_GUIDANCE_START_MARKER);
+    const endIndex = existingContent.indexOf(WORKSPACE_GUIDANCE_END_MARKER);
+    if (startIndex !== -1 || endIndex !== -1) {
+        if (startIndex === -1 || endIndex === -1 || endIndex < startIndex) {
+            throw new Error('Invalid OpenSpec workspace guidance marker state in AGENTS.md.');
+        }
+        const before = existingContent.slice(0, startIndex).trimEnd();
+        const after = existingContent
+            .slice(endIndex + WORKSPACE_GUIDANCE_END_MARKER.length)
+            .trimStart();
+        const prefix = before.length > 0 ? `${before}\n\n` : '';
+        const suffix = after.length > 0 ? `\n\n${after.trimEnd()}\n` : '\n';
+        return `${prefix}${block}${suffix}`;
+    }
+    if (existingContent.trim().length === 0) {
+        return `${block}\n`;
+    }
+    return `${existingContent.trimEnd()}\n\n${block}\n`;
+}
+export function buildWorkspaceCodeWorkspaceContent(links, resolvedContext) {
+    const folders = [
+        ...links.map((link) => ({
+            name: link.name,
+            path: link.path,
+        })),
+        ...(resolvedContext
+            ? [
+                {
+                    name: WORKSPACE_OPEN_INITIATIVE_FOLDER_LABEL,
+                    path: resolvedContext.initiative.root,
+                },
+            ]
+            : []),
+        {
+            name: WORKSPACE_OPEN_ROOT_FOLDER_LABEL,
+            path: '.',
+        },
+    ];
+    return `${JSON.stringify({ folders }, null, 2)}\n`;
+}
+export async function writeWorkspaceCodeWorkspaceFile(codeWorkspacePath, links, resolvedContext) {
+    await FileSystemUtils.writeFile(codeWorkspacePath, buildWorkspaceCodeWorkspaceContent(links, resolvedContext));
+}
+export async function resolveWorkspaceOpenLinks(viewState) {
+    const links = [];
+    const skipped = [];
+    for (const linkName of Object.keys(viewState.links).sort((a, b) => a.localeCompare(b))) {
+        const localPath = viewState.links[linkName] ?? null;
+        if (!localPath) {
+            skipped.push({
+                name: linkName,
+                path: null,
+                reason: 'missing-local-path',
+            });
+            continue;
+        }
+        if (!(await directoryExists(localPath))) {
+            skipped.push({
+                name: linkName,
+                path: localPath,
+                reason: 'path-missing',
+            });
+            continue;
+        }
+        links.push({
+            name: linkName,
+            path: localPath,
+        });
+    }
+    return { links, skipped };
+}
+async function syncWorkspaceGuidance(workspaceRoot, viewState, resolvedContext) {
+    const agentsPath = path.join(workspaceRoot, 'AGENTS.md');
+    const existingContent = (await fileExists(agentsPath))
+        ? await fs.readFile(agentsPath, 'utf-8')
+        : '';
+    await FileSystemUtils.writeFile(agentsPath, applyWorkspaceGuidanceBlock(existingContent, viewState, resolvedContext));
+    return agentsPath;
+}
+async function syncWorkspaceCodeWorkspace(workspaceRoot, viewState, links, resolvedContext) {
+    const codeWorkspacePath = getWorkspaceCodeWorkspacePath(workspaceRoot, viewState.name);
+    await writeWorkspaceCodeWorkspaceFile(codeWorkspacePath, links, resolvedContext);
+    return codeWorkspacePath;
+}
+async function cleanupLegacyWorkspaceIgnoreRules(workspaceRoot, workspaceName) {
+    const gitignorePath = path.join(workspaceRoot, '.gitignore');
+    if (!(await fileExists(gitignorePath))) {
+        return;
+    }
+    const legacyGeneratedPattern = getWorkspaceCodeWorkspaceFileName(workspaceName);
+    const existingContent = await fs.readFile(gitignorePath, 'utf-8');
+    const existingLines = existingContent.split(/\r?\n/u);
+    const nonEmptyLines = existingLines.filter((line) => line.trim().length > 0);
+    const isPureLegacyGeneratedFile = nonEmptyLines.length === 1 && nonEmptyLines[0]?.trim() === legacyGeneratedPattern;
+    if (!isPureLegacyGeneratedFile) {
+        return;
+    }
+    await fs.rm(gitignorePath, { force: true });
+}
+export async function syncWorkspaceOpenSurface(workspaceRoot, viewState, resolvedContext) {
+    const openLinks = await resolveWorkspaceOpenLinks(viewState);
+    const agentsPath = await syncWorkspaceGuidance(workspaceRoot, viewState, resolvedContext);
+    const codeWorkspacePath = await syncWorkspaceCodeWorkspace(workspaceRoot, viewState, openLinks.links, resolvedContext);
+    await cleanupLegacyWorkspaceIgnoreRules(workspaceRoot, viewState.name);
+    return {
+        ...openLinks,
+        generated: {
+            agentsPath,
+            codeWorkspacePath,
+        },
+    };
+}
+//# sourceMappingURL=open-surface.js.map

package/dist/core/workspace/openers.d.ts

@@ -0,0 +1,21 @@
+import { WorkspacePreferredOpener, WorkspaceSupportedOpenerValue } from './foundation.js';
+export interface WorkspaceOpenerChoice {
+    value: WorkspaceSupportedOpenerValue;
+    label: string;
+    opener: WorkspacePreferredOpener;
+    executable: string;
+    available: boolean;
+    unavailableNote: string | null;
+}
+export declare function isWorkspaceExecutableAvailable(executable: string, options?: {
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+}): boolean;
+export declare function getWorkspaceOpenerExecutable(opener: WorkspacePreferredOpener): string;
+export declare function getWorkspaceOpenerLabel(opener: WorkspacePreferredOpener): string;
+export declare function listWorkspaceOpenerChoices(options?: {
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+}): WorkspaceOpenerChoice[];
+export declare function getDefaultWorkspaceOpenerChoiceValue(choices: WorkspaceOpenerChoice[]): WorkspaceSupportedOpenerValue;
+//# sourceMappingURL=openers.d.ts.map

package/dist/core/workspace/openers.js

@@ -0,0 +1,124 @@
+import * as nodeFs from 'node:fs';
+import * as path from 'node:path';
+import { parseWorkspacePreferredOpenerValue, } from './foundation.js';
+const fs = nodeFs;
+const WORKSPACE_OPENER_CHOICE_DEFINITIONS = [
+    {
+        value: 'editor',
+        label: 'VS Code editor',
+        executable: 'code',
+    },
+    {
+        value: 'codex-cli',
+        label: 'codex-cli',
+        executable: 'codex',
+    },
+    {
+        value: 'claude',
+        label: 'Claude',
+        executable: 'claude',
+    },
+    {
+        value: 'github-copilot',
+        label: 'GitHub Copilot in VS Code',
+        executable: 'code',
+    },
+];
+function getPathValue(env) {
+    return env.PATH ?? env.Path ?? env.path ?? '';
+}
+function getPathExts(env, platform) {
+    if (platform !== 'win32') {
+        return [''];
+    }
+    const pathExt = env.PATHEXT ?? '.COM;.EXE;.BAT;.CMD';
+    return pathExt
+        .split(';')
+        .map((extension) => extension.trim())
+        .filter((extension) => extension.length > 0);
+}
+function isExecutableFile(candidatePath, platform) {
+    try {
+        const stats = fs.statSync(candidatePath);
+        if (!stats.isFile()) {
+            return false;
+        }
+        if (platform === 'win32') {
+            return true;
+        }
+        fs.accessSync(candidatePath, fs.constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function isWorkspaceExecutableAvailable(executable, options = {}) {
+    const env = options.env ?? process.env;
+    const platform = options.platform ?? process.platform;
+    if (executable.includes('/') || executable.includes('\\')) {
+        return isExecutableFile(executable, platform);
+    }
+    const pathEntries = getPathValue(env)
+        .split(path.delimiter)
+        .filter((entry) => entry.length > 0);
+    const pathExts = getPathExts(env, platform);
+    for (const entry of pathEntries) {
+        for (const extension of pathExts) {
+            const candidate = path.join(entry, executable + extension);
+            if (isExecutableFile(candidate, platform)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+export function getWorkspaceOpenerExecutable(opener) {
+    const openerId = opener.id;
+    if (opener.kind === 'editor') {
+        return 'code';
+    }
+    if (openerId === 'github-copilot') {
+        return 'code';
+    }
+    if (openerId === 'codex-cli' || openerId === 'codex') {
+        return 'codex';
+    }
+    return opener.id;
+}
+export function getWorkspaceOpenerLabel(opener) {
+    const openerId = opener.id;
+    if (opener.kind === 'editor') {
+        return 'VS Code editor';
+    }
+    if (openerId === 'github-copilot') {
+        return 'GitHub Copilot in VS Code';
+    }
+    if (openerId === 'codex-cli' || openerId === 'codex') {
+        return 'codex-cli';
+    }
+    return 'Claude';
+}
+export function listWorkspaceOpenerChoices(options = {}) {
+    const choices = WORKSPACE_OPENER_CHOICE_DEFINITIONS.map((definition) => {
+        const available = isWorkspaceExecutableAvailable(definition.executable, options);
+        return {
+            value: definition.value,
+            label: definition.label,
+            opener: parseWorkspacePreferredOpenerValue(definition.value),
+            executable: definition.executable,
+            available,
+            unavailableNote: available ? null : `${definition.executable} not found on PATH`,
+        };
+    });
+    return choices.sort((a, b) => {
+        if (a.available !== b.available) {
+            return a.available ? -1 : 1;
+        }
+        return 0;
+    });
+}
+export function getDefaultWorkspaceOpenerChoiceValue(choices) {
+    return choices.find((choice) => choice.available)?.value ?? 'editor';
+}
+//# sourceMappingURL=openers.js.map

package/dist/core/workspace/registry.d.ts

@@ -0,0 +1,24 @@
+export declare const MANAGED_WORKSPACES_DIR_NAME = "workspaces";
+export declare const WORKSPACE_REGISTRY_FILE_NAME = "registry.yaml";
+export interface WorkspaceRegistryState {
+    version: 1;
+    workspaces: Record<string, string>;
+}
+export interface WorkspaceRegistryEntry {
+    name: string;
+    workspaceRoot: string;
+}
+export interface WorkspacePathOptions {
+    globalDataDir?: string;
+}
+export declare function getManagedWorkspacesDir(options?: WorkspacePathOptions): string;
+export declare function getManagedWorkspaceRoot(workspaceName: string, options?: WorkspacePathOptions): string;
+export declare function getWorkspaceRegistryPath(options?: WorkspacePathOptions): string;
+export declare function parseWorkspaceRegistryState(content: string): WorkspaceRegistryState;
+export declare function serializeWorkspaceRegistryState(state: WorkspaceRegistryState): string;
+export declare function listWorkspaceRegistryEntries(registry: WorkspaceRegistryState): WorkspaceRegistryEntry[];
+export declare function listKnownWorkspaceEntries(options?: WorkspacePathOptions): Promise<WorkspaceRegistryEntry[]>;
+export declare function listManagedWorkspaceEntries(options?: WorkspacePathOptions): Promise<WorkspaceRegistryEntry[]>;
+export declare function readWorkspaceRegistryState(options?: WorkspacePathOptions): Promise<WorkspaceRegistryState | null>;
+export declare function writeWorkspaceRegistryState(state: WorkspaceRegistryState, options?: WorkspacePathOptions): Promise<void>;
+//# sourceMappingURL=registry.d.ts.map