@fission-ai/openspec 1.4.1 → 1.6.0-beta.1

package/dist/commands/show.js

@@ -1,5 +1,6 @@
 import { isInteractive } from '../utils/interactive.js';
 import { getActiveChangeIds, getSpecIds } from '../utils/item-discovery.js';
+import { resolveRootForCommand, toRootOutput, withStoreFlag, isStoreSelectedRoot, } from '../core/root-selection.js';
 import { ChangeCommand } from './change.js';
 import { SpecCommand } from './spec.js';
 import { nearestMatches } from '../utils/match.js';
@@ -7,6 +8,10 @@ const CHANGE_FLAG_KEYS = new Set(['deltasOnly', 'requirementsOnly']);
 const SPEC_FLAG_KEYS = new Set(['requirements', 'scenarios', 'requirement']);
 export class ShowCommand {
     async execute(itemName, options = {}) {
+        const root = await resolveRootForCommand(options, { json: options.json });
+        if (!root) {
+            return;
+        }
         const interactive = isInteractive(options);
         const typeOverride = this.normalizeType(options.type);
         if (!itemName) {
@@ -19,14 +24,14 @@ export class ShowCommand {
                         { name: 'Spec', value: 'spec' },
                     ],
                 });
-                await this.runInteractiveByType(type, options);
+                await this.runInteractiveByType(type, options, root);
                 return;
             }
-            this.printNonInteractiveHint();
+            this.printNonInteractiveHint(root);
             process.exitCode = 1;
             return;
         }
-        await this.showDirect(itemName, { typeOverride, options });
+        await this.showDirect(itemName, { typeOverride, options, root });
     }
     normalizeType(value) {
         if (!value)
@@ -36,78 +41,118 @@ export class ShowCommand {
             return v;
         return undefined;
     }
-    async runInteractiveByType(type, options) {
+    delegateOptions(root, options) {
+        return {
+            ...options,
+            ...(options.json ? { rootOutput: toRootOutput(root) } : {}),
+        };
+    }
+    async runInteractiveByType(type, options, root) {
         const { select } = await import('@inquirer/prompts');
         if (type === 'change') {
-            const changes = await getActiveChangeIds();
+            const changes = await getActiveChangeIds(root.path);
             if (changes.length === 0) {
                 console.error('No changes found.');
                 process.exitCode = 1;
                 return;
             }
             const picked = await select({ message: 'Pick a change', choices: changes.map(id => ({ name: id, value: id })) });
-            const cmd = new ChangeCommand();
-            await cmd.show(picked, options);
+            const cmd = new ChangeCommand(root.path);
+            await cmd.show(picked, this.delegateOptions(root, options));
             return;
         }
-        const specs = await getSpecIds();
+        const specs = await getSpecIds(root.path);
         if (specs.length === 0) {
             console.error('No specs found.');
             process.exitCode = 1;
             return;
         }
         const picked = await select({ message: 'Pick a spec', choices: specs.map(id => ({ name: id, value: id })) });
-        const cmd = new SpecCommand();
-        await cmd.show(picked, options);
+        const cmd = new SpecCommand(root.path);
+        await cmd.show(picked, this.delegateOptions(root, options));
     }
     async showDirect(itemName, params) {
+        const root = params.root;
         // Optimize lookups when type is pre-specified
         let isChange = false;
         let isSpec = false;
         let changes = [];
         let specs = [];
         if (params.typeOverride === 'change') {
-            changes = await getActiveChangeIds();
+            changes = await getActiveChangeIds(root.path);
             isChange = changes.includes(itemName);
         }
         else if (params.typeOverride === 'spec') {
-            specs = await getSpecIds();
+            specs = await getSpecIds(root.path);
             isSpec = specs.includes(itemName);
         }
         else {
-            [changes, specs] = await Promise.all([getActiveChangeIds(), getSpecIds()]);
+            [changes, specs] = await Promise.all([getActiveChangeIds(root.path), getSpecIds(root.path)]);
             isChange = changes.includes(itemName);
             isSpec = specs.includes(itemName);
         }
         const resolvedType = params.typeOverride ?? (isChange ? 'change' : isSpec ? 'spec' : undefined);
         if (!resolvedType) {
-            console.error(`Unknown item '${itemName}'`);
             const suggestions = nearestMatches(itemName, [...changes, ...specs]);
-            if (suggestions.length)
-                console.error(`Did you mean: ${suggestions.join(', ')}?`);
+            const message = suggestions.length
+                ? `Unknown item '${itemName}'. Did you mean: ${suggestions.join(', ')}?`
+                : `Unknown item '${itemName}'.`;
+            if (params.options.json) {
+                console.log(JSON.stringify({ status: [{ severity: 'error', code: 'unknown_item', message }] }, null, 2));
+            }
+            else {
+                console.error(message);
+            }
             process.exitCode = 1;
             return;
         }
         if (!params.typeOverride && isChange && isSpec) {
+            if (params.options.json) {
+                console.log(JSON.stringify({
+                    status: [
+                        {
+                            severity: 'error',
+                            code: 'ambiguous_item',
+                            message: `Ambiguous item '${itemName}' matches both a change and a spec.`,
+                            fix: 'Pass --type change|spec.',
+                        },
+                    ],
+                }, null, 2));
+                process.exitCode = 1;
+                return;
+            }
             console.error(`Ambiguous item '${itemName}' matches both a change and a spec.`);
-            console.error('Pass --type change|spec, or use: openspec change show / openspec spec show');
+            // The noun-form commands are cwd-based and cannot reach a selected store.
+            if (isStoreSelectedRoot(root)) {
+                console.error('Pass --type change|spec.');
+            }
+            else {
+                console.error('Pass --type change|spec, or use: openspec change show / openspec spec show');
+            }
             process.exitCode = 1;
             return;
         }
         this.warnIrrelevantFlags(resolvedType, params.options);
         if (resolvedType === 'change') {
-            const cmd = new ChangeCommand();
-            await cmd.show(itemName, params.options);
+            const cmd = new ChangeCommand(root.path);
+            await cmd.show(itemName, this.delegateOptions(root, params.options));
             return;
         }
-        const cmd = new SpecCommand();
-        await cmd.show(itemName, params.options);
+        const cmd = new SpecCommand(root.path);
+        await cmd.show(itemName, this.delegateOptions(root, params.options));
     }
-    printNonInteractiveHint() {
+    printNonInteractiveHint(root) {
         console.error('Nothing to show. Try one of:');
-        console.error('  openspec show <item>');
-        console.error('  openspec change show');
-        console.error('  openspec spec show');
+        console.error(`  ${withStoreFlag(root, 'openspec show <item>')}`);
+        if (isStoreSelectedRoot(root)) {
+            // The noun-form commands are cwd-based and cannot reach a selected store.
+            console.error(`  ${withStoreFlag(root, 'openspec show <item> --type change')}`);
+            console.error(`  ${withStoreFlag(root, 'openspec show <item> --type spec')}`);
+        }
+        else {
+            console.error('  openspec change show');
+            console.error('  openspec spec show');
+        }
         console.error('Or run in an interactive terminal.');
     }
     warnIrrelevantFlags(type, options) {

package/dist/commands/spec.d.ts

@@ -1,13 +1,17 @@
 import { program } from 'commander';
+import type { RootOutput } from '../core/root-selection.js';
 interface ShowOptions {
     json?: boolean;
     requirements?: boolean;
     scenarios?: boolean;
     requirement?: string;
     noInteractive?: boolean;
+    rootOutput?: RootOutput;
 }
 export declare class SpecCommand {
-    private SPECS_DIR;
+    private specsDir;
+    private rootPath?;
+    constructor(rootPath?: string);
     show(specId?: string, options?: ShowOptions): Promise<void>;
 }
 export declare function registerSpecCommand(rootProgram: typeof program): import("commander").Command;

package/dist/commands/spec.js

@@ -45,11 +45,18 @@ function printSpecTextRaw(specPath) {
     console.log(content);
 }
 export class SpecCommand {
-    SPECS_DIR = 'openspec/specs';
+    specsDir;
+    rootPath;
+    // rootPath is set only by root-aware callers (top-level `show`); the
+    // deprecated noun-form commands stay cwd-based.
+    constructor(rootPath) {
+        this.rootPath = rootPath;
+        this.specsDir = rootPath ? join(rootPath, 'openspec', 'specs') : SPECS_DIR;
+    }
     async show(specId, options = {}) {
         if (!specId) {
             const canPrompt = isInteractive(options);
-            const specIds = await getSpecIds();
+            const specIds = await getSpecIds(this.rootPath ?? process.cwd());
             if (canPrompt && specIds.length > 0) {
                 const { select } = await import('@inquirer/prompts');
                 specId = await select({
@@ -61,9 +68,12 @@ export class SpecCommand {
                 throw new Error('Missing required argument <spec-id>');
             }
         }
-        const specPath = join(this.SPECS_DIR, specId, 'spec.md');
+        const specPath = join(this.specsDir, specId, 'spec.md');
         if (!existsSync(specPath)) {
-            throw new Error(`Spec '${specId}' not found at openspec/specs/${specId}/spec.md`);
+            // Root-aware callers get the absolute path; the cwd-based noun form
+            // keeps its historical forward-slash relative message on all platforms.
+            const displayPath = this.rootPath ? specPath : `openspec/specs/${specId}/spec.md`;
+            throw new Error(`Spec '${specId}' not found at ${displayPath}`);
         }
         if (options.json) {
             if (options.requirements && options.requirement) {
@@ -78,6 +88,7 @@ export class SpecCommand {
                 requirementCount: filtered.requirements.length,
                 requirements: filtered.requirements,
                 metadata: parsed.metadata ?? { version: '1.0.0', format: 'openspec' },
+                ...(options.rootOutput ? { root: options.rootOutput } : {}),
             };
             console.log(JSON.stringify(output, null, 2));
             return;

package/dist/commands/store.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerStoreCommand(program: Command): void;
+//# sourceMappingURL=store.d.ts.map