gmc-openspec 1.0.0

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,119 @@
+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',
+        label: 'Codex',
+        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) {
+    if (opener.kind === 'editor') {
+        return 'code';
+    }
+    if (opener.id === 'github-copilot') {
+        return 'code';
+    }
+    return opener.id;
+}
+export function getWorkspaceOpenerLabel(opener) {
+    if (opener.kind === 'editor') {
+        return 'VS Code editor';
+    }
+    if (opener.id === 'github-copilot') {
+        return 'GitHub Copilot in VS Code';
+    }
+    if (opener.id === 'codex') {
+        return 'Codex';
+    }
+    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/skills.d.ts

@@ -0,0 +1,55 @@
+import { type AIToolOption } from '../config.js';
+import { type Delivery, type Profile } from '../global-config.js';
+import type { WorkspaceLocalState, WorkspaceSkillState } from './foundation.js';
+export interface WorkspaceSkillAgentResult {
+    tool_id: string;
+    name: string;
+    skills_path: string;
+    workflow_ids: string[];
+}
+export interface WorkspaceSkillRemovedResult extends WorkspaceSkillAgentResult {
+    reason: 'agent_unselected' | 'workflow_unselected';
+}
+export interface WorkspaceSkillSkippedResult {
+    tool_id?: string;
+    name?: string;
+    reason: string;
+    message: string;
+}
+export interface WorkspaceSkillFailedResult {
+    tool_id: string;
+    name: string;
+    error: string;
+}
+export interface WorkspaceSkillInstallationReport {
+    profile: Profile;
+    delivery: Delivery;
+    workflow_ids: string[];
+    selected_agents: string[];
+    skills_only: true;
+    delivery_notice: string | null;
+    generated: WorkspaceSkillAgentResult[];
+    added: WorkspaceSkillAgentResult[];
+    refreshed: WorkspaceSkillAgentResult[];
+    removed: WorkspaceSkillRemovedResult[];
+    skipped: WorkspaceSkillSkippedResult[];
+    failed: WorkspaceSkillFailedResult[];
+}
+type WorkspaceSkillCapableTool = AIToolOption & {
+    skillsDir: string;
+};
+export declare function getCurrentWorkspaceSkillProfileSelection(): {
+    profile: Profile;
+    delivery: Delivery;
+    workflow_ids: string[];
+};
+export declare function hasWorkspaceSkillProfileDrift(localState: Pick<WorkspaceLocalState, 'workspace_skills'> | null | undefined): boolean;
+export declare function getWorkspaceSkillCapableTools(): WorkspaceSkillCapableTool[];
+export declare function getWorkspaceSkillToolIds(): string[];
+export declare function parseWorkspaceSkillToolsValue(rawTools: string): string[];
+export declare function createWorkspaceSkillSkippedReport(reason: string, message: string): WorkspaceSkillInstallationReport;
+export declare function getWorkspaceSkillDirectory(workspaceRoot: string, toolId: string): string;
+export declare function generateWorkspaceAgentSkills(workspaceRoot: string, selectedAgentIds: string[]): Promise<WorkspaceSkillInstallationReport>;
+export declare function updateWorkspaceAgentSkills(workspaceRoot: string, selectedAgentIds: string[], previousSkillState?: WorkspaceSkillState): Promise<WorkspaceSkillInstallationReport>;
+export {};
+//# sourceMappingURL=skills.d.ts.map

package/dist/core/workspace/skills.js

@@ -0,0 +1,334 @@
+import * as nodeFs from 'node:fs';
+import { createRequire } from 'node:module';
+import { FileSystemUtils } from '../../utils/file-system.js';
+import { transformToHyphenCommands } from '../../utils/command-references.js';
+import { AI_TOOLS } from '../config.js';
+import { getGlobalConfig } from '../global-config.js';
+import { getProfileWorkflows } from '../profiles.js';
+import { generateSkillContent, getSkillTemplates, getToolSkillStatus, getToolsWithSkillsDir, extractGeneratedByVersion, } from '../shared/index.js';
+const require = createRequire(import.meta.url);
+const { version: OPENSPEC_VERSION } = require('../../../package.json');
+const fs = nodeFs.promises;
+function resolveWorkspaceSkillProfileContext() {
+    const globalConfig = getGlobalConfig();
+    const profile = globalConfig.profile ?? 'core';
+    const delivery = globalConfig.delivery ?? 'both';
+    const workflowIds = [...getProfileWorkflows(profile, globalConfig.workflows)];
+    const deliveryNotice = delivery === 'skills'
+        ? null
+        : 'Workspace setup installs skills only; workspace command generation is not part of this slice.';
+    return {
+        profile,
+        delivery,
+        workflowIds,
+        deliveryNotice,
+    };
+}
+export function getCurrentWorkspaceSkillProfileSelection() {
+    const profileContext = resolveWorkspaceSkillProfileContext();
+    return {
+        profile: profileContext.profile,
+        delivery: profileContext.delivery,
+        workflow_ids: profileContext.workflowIds,
+    };
+}
+function arraysEqual(left, right) {
+    const leftValues = left ?? [];
+    if (leftValues.length !== right.length) {
+        return false;
+    }
+    const leftSet = new Set(leftValues);
+    const rightSet = new Set(right);
+    if (leftSet.size !== rightSet.size) {
+        return false;
+    }
+    return [...leftSet].every((value) => rightSet.has(value));
+}
+export function hasWorkspaceSkillProfileDrift(localState) {
+    const workspaceSkills = localState?.workspace_skills;
+    if (!workspaceSkills) {
+        return false;
+    }
+    const current = getCurrentWorkspaceSkillProfileSelection();
+    return (workspaceSkills.last_applied_profile !== current.profile ||
+        workspaceSkills.last_applied_delivery !== current.delivery ||
+        !arraysEqual(workspaceSkills.last_applied_workflow_ids, current.workflow_ids));
+}
+function makeBaseWorkspaceSkillReport(selectedAgentIds, profileContext = resolveWorkspaceSkillProfileContext()) {
+    return {
+        profile: profileContext.profile,
+        delivery: profileContext.delivery,
+        workflow_ids: profileContext.workflowIds,
+        selected_agents: selectedAgentIds,
+        skills_only: true,
+        delivery_notice: profileContext.deliveryNotice,
+        generated: [],
+        added: [],
+        refreshed: [],
+        removed: [],
+        skipped: [],
+        failed: [],
+    };
+}
+export function getWorkspaceSkillCapableTools() {
+    return AI_TOOLS.filter((tool) => Boolean(tool.skillsDir));
+}
+export function getWorkspaceSkillToolIds() {
+    return getToolsWithSkillsDir();
+}
+export function parseWorkspaceSkillToolsValue(rawTools) {
+    const raw = rawTools.trim();
+    if (raw.length === 0) {
+        throw new Error('The --tools option requires a value. Use "all", "none", or a comma-separated list of agent IDs.');
+    }
+    const availableTools = getWorkspaceSkillToolIds();
+    const availableSet = new Set(availableTools);
+    const availableList = ['all', 'none', ...availableTools].join(', ');
+    const lowerRaw = raw.toLowerCase();
+    if (lowerRaw === 'all') {
+        return availableTools;
+    }
+    if (lowerRaw === 'none') {
+        return [];
+    }
+    const tokens = raw
+        .split(',')
+        .map((token) => token.trim())
+        .filter((token) => token.length > 0);
+    if (tokens.length === 0) {
+        throw new Error('The --tools option requires at least one agent ID when not using "all" or "none".');
+    }
+    const normalizedTokens = tokens.map((token) => token.toLowerCase());
+    if (normalizedTokens.some((token) => token === 'all' || token === 'none')) {
+        throw new Error('Cannot combine reserved values "all" or "none" with specific agent IDs.');
+    }
+    const invalidTokens = tokens.filter((_token, index) => !availableSet.has(normalizedTokens[index]));
+    if (invalidTokens.length > 0) {
+        throw new Error(`Invalid agent(s): ${invalidTokens.join(', ')}. Available values: ${availableList}`);
+    }
+    const deduped = [];
+    for (const token of normalizedTokens) {
+        if (!deduped.includes(token)) {
+            deduped.push(token);
+        }
+    }
+    return deduped;
+}
+export function createWorkspaceSkillSkippedReport(reason, message) {
+    const report = makeBaseWorkspaceSkillReport([]);
+    report.skipped.push({
+        reason,
+        message,
+    });
+    return report;
+}
+function getWorkspaceSkillTool(toolId) {
+    const tool = getWorkspaceSkillCapableTools().find((candidate) => candidate.value === toolId);
+    if (!tool) {
+        throw new Error(`Unknown workspace skill agent '${toolId}'.`);
+    }
+    return tool;
+}
+function getWorkspaceSkillDirectoryForTool(workspaceRoot, tool) {
+    return FileSystemUtils.joinPath(workspaceRoot, tool.skillsDir, 'skills');
+}
+export function getWorkspaceSkillDirectory(workspaceRoot, toolId) {
+    return getWorkspaceSkillDirectoryForTool(workspaceRoot, getWorkspaceSkillTool(toolId));
+}
+function makeAgentResult(workspaceRoot, tool, workflowIds) {
+    return {
+        tool_id: tool.value,
+        name: tool.name,
+        skills_path: getWorkspaceSkillDirectoryForTool(workspaceRoot, tool),
+        workflow_ids: workflowIds,
+    };
+}
+function getManagedWorkspaceSkillEntries() {
+    return getSkillTemplates().map(({ workflowId, dirName }) => ({ workflowId, dirName }));
+}
+async function pathExists(targetPath) {
+    try {
+        await fs.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isOpenSpecManagedSkillDir(skillDir) {
+    const skillFile = FileSystemUtils.joinPath(skillDir, 'SKILL.md');
+    return extractGeneratedByVersion(skillFile) !== null;
+}
+async function removeManagedWorkflowSkillDirs(workspaceRoot, tool, desiredWorkflowIds, reason) {
+    const desiredSet = new Set(desiredWorkflowIds);
+    const skillsDir = getWorkspaceSkillDirectoryForTool(workspaceRoot, tool);
+    const removedWorkflowIds = [];
+    for (const { workflowId, dirName } of getManagedWorkspaceSkillEntries()) {
+        if (desiredSet.has(workflowId)) {
+            continue;
+        }
+        const skillDir = FileSystemUtils.joinPath(skillsDir, dirName);
+        if (!(await pathExists(skillDir))) {
+            continue;
+        }
+        if (!isOpenSpecManagedSkillDir(skillDir)) {
+            continue;
+        }
+        await fs.rm(skillDir, { recursive: true, force: true });
+        removedWorkflowIds.push(workflowId);
+    }
+    if (removedWorkflowIds.length === 0) {
+        return null;
+    }
+    return {
+        ...makeAgentResult(workspaceRoot, tool, removedWorkflowIds),
+        reason,
+    };
+}
+export async function generateWorkspaceAgentSkills(workspaceRoot, selectedAgentIds) {
+    const profileContext = resolveWorkspaceSkillProfileContext();
+    const report = makeBaseWorkspaceSkillReport(selectedAgentIds, profileContext);
+    if (selectedAgentIds.length === 0) {
+        report.skipped.push({
+            reason: 'no_agents_selected',
+            message: 'No workspace agent skills were selected.',
+        });
+        return report;
+    }
+    const skillTemplates = getSkillTemplates(profileContext.workflowIds);
+    if (skillTemplates.length === 0) {
+        for (const toolId of selectedAgentIds) {
+            const tool = getWorkspaceSkillTool(toolId);
+            report.skipped.push({
+                tool_id: tool.value,
+                name: tool.name,
+                reason: 'no_profile_workflows',
+                message: 'The active global profile does not select any workflows.',
+            });
+        }
+        return report;
+    }
+    for (const toolId of selectedAgentIds) {
+        const tool = getWorkspaceSkillTool(toolId);
+        const wasConfigured = getToolSkillStatus(workspaceRoot, tool.value).configured;
+        try {
+            const skillsDir = getWorkspaceSkillDirectoryForTool(workspaceRoot, tool);
+            const transformer = tool.value === 'opencode' || tool.value === 'pi' ? transformToHyphenCommands : undefined;
+            for (const { template, dirName } of skillTemplates) {
+                const skillFile = FileSystemUtils.joinPath(skillsDir, dirName, 'SKILL.md');
+                const skillContent = generateSkillContent(template, OPENSPEC_VERSION, transformer);
+                await FileSystemUtils.writeFile(skillFile, skillContent);
+            }
+            const result = makeAgentResult(workspaceRoot, tool, profileContext.workflowIds);
+            if (wasConfigured) {
+                report.refreshed.push(result);
+            }
+            else {
+                report.generated.push(result);
+            }
+        }
+        catch (error) {
+            report.failed.push({
+                tool_id: tool.value,
+                name: tool.name,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return report;
+}
+export async function updateWorkspaceAgentSkills(workspaceRoot, selectedAgentIds, previousSkillState) {
+    const profileContext = resolveWorkspaceSkillProfileContext();
+    const report = makeBaseWorkspaceSkillReport(selectedAgentIds, profileContext);
+    const previousSelectedAgentIds = previousSkillState?.selected_agents ?? [];
+    const previousSelectedSet = new Set(previousSelectedAgentIds);
+    const selectedSet = new Set(selectedAgentIds);
+    const skillTemplates = getSkillTemplates(profileContext.workflowIds);
+    for (const toolId of previousSelectedAgentIds) {
+        if (selectedSet.has(toolId)) {
+            continue;
+        }
+        const tool = getWorkspaceSkillTool(toolId);
+        try {
+            const removed = await removeManagedWorkflowSkillDirs(workspaceRoot, tool, [], 'agent_unselected');
+            if (removed) {
+                report.removed.push(removed);
+            }
+        }
+        catch (error) {
+            report.failed.push({
+                tool_id: tool.value,
+                name: tool.name,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    if (selectedAgentIds.length === 0) {
+        if (report.removed.length === 0) {
+            report.skipped.push({
+                reason: previousSkillState ? 'no_agents_selected' : 'no_stored_agent_selection',
+                message: previousSkillState
+                    ? 'No workspace agent skills were selected.'
+                    : 'No workspace agent skill selection is stored. Pass --tools <ids> to install skills.',
+            });
+        }
+        return report;
+    }
+    if (skillTemplates.length === 0) {
+        for (const toolId of selectedAgentIds) {
+            const tool = getWorkspaceSkillTool(toolId);
+            try {
+                const removed = await removeManagedWorkflowSkillDirs(workspaceRoot, tool, [], 'workflow_unselected');
+                if (removed) {
+                    report.removed.push(removed);
+                }
+            }
+            catch (error) {
+                report.failed.push({
+                    tool_id: tool.value,
+                    name: tool.name,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+            report.skipped.push({
+                tool_id: tool.value,
+                name: tool.name,
+                reason: 'no_profile_workflows',
+                message: 'The active global profile does not select any workflows.',
+            });
+        }
+        return report;
+    }
+    for (const toolId of selectedAgentIds) {
+        const tool = getWorkspaceSkillTool(toolId);
+        try {
+            const skillsDir = getWorkspaceSkillDirectoryForTool(workspaceRoot, tool);
+            const transformer = tool.value === 'opencode' || tool.value === 'pi' ? transformToHyphenCommands : undefined;
+            for (const { template, dirName } of skillTemplates) {
+                const skillFile = FileSystemUtils.joinPath(skillsDir, dirName, 'SKILL.md');
+                const skillContent = generateSkillContent(template, OPENSPEC_VERSION, transformer);
+                await FileSystemUtils.writeFile(skillFile, skillContent);
+            }
+            const removed = await removeManagedWorkflowSkillDirs(workspaceRoot, tool, profileContext.workflowIds, 'workflow_unselected');
+            if (removed) {
+                report.removed.push(removed);
+            }
+            const result = makeAgentResult(workspaceRoot, tool, profileContext.workflowIds);
+            if (previousSelectedSet.has(toolId)) {
+                report.refreshed.push(result);
+            }
+            else {
+                report.added.push(result);
+            }
+        }
+        catch (error) {
+            report.failed.push({
+                tool_id: tool.value,
+                name: tool.name,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return report;
+}
+//# sourceMappingURL=skills.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