gmc-openspec 1.0.0

package/dist/commands/workflow/status.js

@@ -0,0 +1,87 @@
+/**
+ * Status Command
+ *
+ * Displays artifact completion status for a change.
+ */
+import ora from 'ora';
+import chalk from 'chalk';
+import { resolveCurrentPlanningHomeSync, getChangeDir } from '../../core/planning-home.js';
+import { loadChangeContext, formatChangeStatus, } from '../../core/artifact-graph/index.js';
+import { validateChangeExists, validateSchemaExists, getAvailableChanges, getStatusIndicator, getStatusColor, } from './shared.js';
+// -----------------------------------------------------------------------------
+// Command Implementation
+// -----------------------------------------------------------------------------
+export async function statusCommand(options) {
+    const spinner = options.json ? undefined : ora('Loading change status...').start();
+    try {
+        const planningHome = resolveCurrentPlanningHomeSync();
+        const projectRoot = planningHome.root;
+        // Handle no-changes case gracefully — status is informational,
+        // so "no changes" is a valid state, not an error.
+        if (!options.change) {
+            const available = await getAvailableChanges(projectRoot, planningHome.changesDir);
+            if (available.length === 0) {
+                spinner?.stop();
+                if (options.json) {
+                    console.log(JSON.stringify({ changes: [], message: 'No active changes.' }, null, 2));
+                    return;
+                }
+                console.log('No active changes. Create one with: openspec new change <name>');
+                return;
+            }
+            // Changes exist but --change not provided
+            spinner?.stop();
+            throw new Error(`Missing required option --change. Available changes:\n  ${available.join('\n  ')}`);
+        }
+        const changeName = await validateChangeExists(options.change, projectRoot, planningHome.changesDir);
+        // Validate schema if explicitly provided
+        if (options.schema) {
+            validateSchemaExists(options.schema, projectRoot);
+        }
+        // loadChangeContext will auto-detect schema from metadata if not provided
+        const context = loadChangeContext(projectRoot, changeName, options.schema, {
+            changeDir: getChangeDir(planningHome, changeName),
+            planningHome,
+        });
+        const status = formatChangeStatus(context);
+        spinner?.stop();
+        if (options.json) {
+            console.log(JSON.stringify(status, null, 2));
+            return;
+        }
+        printStatusText(status);
+    }
+    catch (error) {
+        spinner?.stop();
+        throw error;
+    }
+}
+export function printStatusText(status) {
+    const doneCount = status.artifacts.filter((a) => a.status === 'done').length;
+    const total = status.artifacts.length;
+    console.log(`Change: ${status.changeName}`);
+    console.log(`Schema: ${status.schemaName}`);
+    if (status.planningHome) {
+        const label = status.planningHome.kind === 'workspace'
+            ? `workspace${status.planningHome.workspaceName ? ` (${status.planningHome.workspaceName})` : ''}`
+            : 'repo';
+        console.log(`Planning home: ${label}`);
+        console.log(`Change root: ${status.changeRoot}`);
+    }
+    console.log(`Progress: ${doneCount}/${total} artifacts complete`);
+    console.log();
+    for (const artifact of status.artifacts) {
+        const indicator = getStatusIndicator(artifact.status);
+        const color = getStatusColor(artifact.status);
+        let line = `${indicator} ${artifact.id}`;
+        if (artifact.status === 'blocked' && artifact.missingDeps && artifact.missingDeps.length > 0) {
+            line += color(` (blocked by: ${artifact.missingDeps.join(', ')})`);
+        }
+        console.log(line);
+    }
+    if (status.isComplete) {
+        console.log();
+        console.log(chalk.green('All artifacts complete!'));
+    }
+}
+//# sourceMappingURL=status.js.map

package/dist/commands/workflow/templates.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Templates Command
+ *
+ * Shows resolved template paths for all artifacts in a schema.
+ */
+export interface TemplatesOptions {
+    schema?: string;
+    json?: boolean;
+}
+export interface TemplateInfo {
+    artifactId: string;
+    templatePath: string;
+    source: 'project' | 'user' | 'package';
+}
+export declare function templatesCommand(options: TemplatesOptions): Promise<void>;
+//# sourceMappingURL=templates.d.ts.map

package/dist/commands/workflow/templates.js

@@ -0,0 +1,69 @@
+/**
+ * Templates Command
+ *
+ * Shows resolved template paths for all artifacts in a schema.
+ */
+import ora from 'ora';
+import path from 'path';
+import { resolveSchema, getSchemaDir, ArtifactGraph, } from '../../core/artifact-graph/index.js';
+import { FileSystemUtils } from '../../utils/file-system.js';
+import { validateSchemaExists, DEFAULT_SCHEMA } from './shared.js';
+// -----------------------------------------------------------------------------
+// Command Implementation
+// -----------------------------------------------------------------------------
+export async function templatesCommand(options) {
+    const spinner = options.json ? undefined : ora('Loading templates...').start();
+    try {
+        const projectRoot = process.cwd();
+        const schemaName = validateSchemaExists(options.schema ?? DEFAULT_SCHEMA, projectRoot);
+        const schema = resolveSchema(schemaName, projectRoot);
+        const graph = ArtifactGraph.fromSchema(schema);
+        const schemaDir = getSchemaDir(schemaName, projectRoot);
+        // Determine the source (project, user, or package)
+        const { getUserSchemasDir, getProjectSchemasDir, } = await import('../../core/artifact-graph/resolver.js');
+        const projectSchemasDir = getProjectSchemasDir(projectRoot);
+        const userSchemasDir = getUserSchemasDir();
+        // Determine source by checking if schemaDir is inside each base directory
+        // Using path.relative is more robust than startsWith for path comparisons
+        const isInsideDir = (child, parent) => {
+            const relative = path.relative(parent, child);
+            return !relative.startsWith('..') && !path.isAbsolute(relative);
+        };
+        let source;
+        if (isInsideDir(schemaDir, projectSchemasDir)) {
+            source = 'project';
+        }
+        else if (isInsideDir(schemaDir, userSchemasDir)) {
+            source = 'user';
+        }
+        else {
+            source = 'package';
+        }
+        const templates = graph.getAllArtifacts().map((artifact) => ({
+            artifactId: artifact.id,
+            templatePath: FileSystemUtils.canonicalizeExistingPath(path.join(schemaDir, 'templates', artifact.template)),
+            source,
+        }));
+        spinner?.stop();
+        if (options.json) {
+            const output = {};
+            for (const t of templates) {
+                output[t.artifactId] = { path: t.templatePath, source: t.source };
+            }
+            console.log(JSON.stringify(output, null, 2));
+            return;
+        }
+        console.log(`Schema: ${schemaName}`);
+        console.log(`Source: ${source}`);
+        console.log();
+        for (const t of templates) {
+            console.log(`${t.artifactId}:`);
+            console.log(`  ${t.templatePath}`);
+        }
+    }
+    catch (error) {
+        spinner?.stop();
+        throw error;
+    }
+}
+//# sourceMappingURL=templates.js.map

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

@@ -0,0 +1,29 @@
+import { spawn as nodeSpawn } from 'node:child_process';
+import { WorkspaceLocalState, WorkspacePreferredOpener, WorkspaceSharedState, resolveWorkspaceOpenLinks } 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;
+    codeWorkspacePath: string;
+}
+export interface WorkspaceOpenLaunchCommand {
+    executable: string;
+    args: string[];
+    cwd: string;
+    openerLabel: string;
+}
+export type WorkspaceOpenSpawn = typeof nodeSpawn;
+export interface WorkspaceOpenLaunchOptions {
+    spawn?: WorkspaceOpenSpawn;
+    isExecutableAvailable?: (executable: string) => boolean;
+}
+export declare function readWorkspaceOpenState(selected: SelectedWorkspace): Promise<WorkspaceOpenState>;
+export declare function buildWorkspaceOpenLaunchCommand(opener: WorkspacePreferredOpener, workspaceRoot: string, codeWorkspacePath: string, linkedPaths: 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 launchWorkspaceOpenCommand(command: WorkspaceOpenLaunchCommand, options?: WorkspaceOpenLaunchOptions): Promise<void>;
+//# sourceMappingURL=open.d.ts.map

package/dist/commands/workspace/open.js

@@ -0,0 +1,84 @@
+import { createRequire } from 'node:module';
+import { getWorkspaceCodeWorkspacePath, getWorkspaceOpenerExecutable, getWorkspaceOpenerLabel, isWorkspaceExecutableAvailable, readWorkspaceLocalState, readWorkspaceSharedState, resolveWorkspaceOpenLinks, writeWorkspaceCodeWorkspaceFile, } from '../../core/workspace/index.js';
+import { WorkspaceCliError, asErrorMessage } from './types.js';
+export const WORKSPACE_OPEN_MINIMAL_PROMPT = 'Open this OpenSpec workspace.';
+const require = createRequire(import.meta.url);
+const spawn = require('cross-spawn');
+export async function readWorkspaceOpenState(selected) {
+    const sharedState = await readWorkspaceSharedState(selected.root);
+    const localState = await readWorkspaceLocalState(selected.root);
+    return {
+        sharedState,
+        localState,
+        codeWorkspacePath: getWorkspaceCodeWorkspacePath(selected.root, sharedState.name),
+    };
+}
+export function buildWorkspaceOpenLaunchCommand(opener, workspaceRoot, codeWorkspacePath, linkedPaths) {
+    const executable = getWorkspaceOpenerExecutable(opener);
+    const openerLabel = getWorkspaceOpenerLabel(opener);
+    if (opener.kind === 'editor' || opener.id === 'github-copilot') {
+        return {
+            executable,
+            args: [codeWorkspacePath],
+            cwd: workspaceRoot,
+            openerLabel,
+        };
+    }
+    return {
+        executable,
+        args: [
+            ...linkedPaths.flatMap((linkedPath) => ['--add-dir', linkedPath]),
+            WORKSPACE_OPEN_MINIMAL_PROMPT,
+        ],
+        cwd: workspaceRoot,
+        openerLabel,
+    };
+}
+export function assertWorkspaceOpenerAvailable(opener, codeWorkspacePath, isExecutableAvailable = isWorkspaceExecutableAvailable) {
+    const executable = getWorkspaceOpenerExecutable(opener);
+    if (isExecutableAvailable(executable)) {
+        return;
+    }
+    const openerLabel = getWorkspaceOpenerLabel(opener);
+    const manualPath = executable === 'code'
+        ? ` You can open the workspace file manually: ${codeWorkspacePath}`
+        : '';
+    throw new WorkspaceCliError(`${openerLabel} requires '${executable}', but '${executable}' was not found on PATH.${manualPath}`, 'workspace_opener_unavailable', {
+        target: 'workspace.opener',
+        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);
+    return {
+        command: buildWorkspaceOpenLaunchCommand(opener, workspaceRoot, state.codeWorkspacePath, openLinks.links.map((link) => link.path)),
+        skipped: openLinks.skipped,
+    };
+}
+export async function launchWorkspaceOpenCommand(command, options = {}) {
+    const spawnCommand = options.spawn ?? spawn;
+    await new Promise((resolve, reject) => {
+        const child = spawnCommand(command.executable, command.args, {
+            cwd: command.cwd,
+            stdio: 'inherit',
+            shell: false,
+        });
+        child.on('error', (error) => {
+            reject(new WorkspaceCliError(`Could not launch ${command.openerLabel}: ${asErrorMessage(error)}`, 'workspace_opener_launch_failed', {
+                target: 'workspace.opener',
+            }));
+        });
+        child.on('close', (code, signal) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            const reason = signal ? `signal ${signal}` : `exit code ${code}`;
+            reject(new WorkspaceCliError(`${command.openerLabel} exited with ${reason}.`, 'workspace_opener_launch_failed', {
+                target: 'workspace.opener',
+            }));
+        });
+    });
+}
+//# sourceMappingURL=open.js.map

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

@@ -0,0 +1,23 @@
+import { WorkspaceLocalState, WorkspacePreferredOpener, WorkspaceRegistryEntry, WorkspaceRegistryState, WorkspaceSharedState } 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 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 addWorkspaceLink(selected: SelectedWorkspace, nameOrPath: string, linkPath?: string): Promise<WorkspaceLinkMutationPayload>;
+export declare function updateWorkspaceLink(selected: SelectedWorkspace, linkNameInput: string, linkPath: string): Promise<WorkspaceLinkMutationPayload>;
+//# sourceMappingURL=operations.d.ts.map