@codewalla_india/openspec 1.0.1

package/dist/commands/context.js

@@ -0,0 +1,155 @@
+/**
+ * `openspec context` (slice 4.1): the working set a root's declarations
+ * describe, as an agent brief (JSON), a human listing, or an editor
+ * view (`--code-workspace`). Assembly is presentation over the Phase 3
+ * relationship data; doctor is the health surface. The only write this
+ * command can perform is the explicitly requested workspace file.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { Option } from 'commander';
+import { resolveRootForCommand, } from '../core/root-selection.js';
+import { inspectRelationships } from '../core/relationship-health.js';
+import { assembleWorkingSet, buildCodeWorkspaceJson, isAvailableMember, } from '../core/working-set.js';
+import { StoreError } from '../core/store/errors.js';
+import { COMMAND_REGISTRY } from '../core/completions/command-registry.js';
+import { COMMON_FLAGS } from '../core/completions/shared-flags.js';
+import { emitFailure, printJson } from './shared-output.js';
+import { gatherRelationshipData } from './shared-gather.js';
+const FAILURE_PAYLOAD = { root: null, members: [] };
+async function gatherWorkingSet(root) {
+    const data = await gatherRelationshipData(root);
+    // Reuse the 3.6 composition for member classification; the
+    // doctor-only wrong-turn detections and store facts are deliberately
+    // absent — doctor is the health surface.
+    const health = inspectRelationships({
+        root,
+        rootHealthy: data.rootInspection.healthy,
+        rootStatus: data.rootInspection.diagnostics,
+        referenceEntries: data.referenceEntries,
+        registryUnreadable: data.registrySnapshot.unreadable,
+    });
+    return {
+        workingSet: assembleWorkingSet({
+            root,
+            referenceEntries: data.referenceEntries,
+            topLevelStatus: health.status,
+        }),
+        declaredReferenceCount: data.projectConfig?.references?.length ?? 0,
+    };
+}
+function memberLine(member) {
+    return `  ${member.id}  ${member.path}`;
+}
+function printHumanWorkingSet(workingSet, declaredReferenceCount) {
+    const rootLabel = workingSet.root.store_id ?? path.basename(workingSet.root.path);
+    console.log(`Working context for ${rootLabel} (${workingSet.root.path})`);
+    console.log('');
+    console.log('OpenSpec root');
+    console.log(`  ${rootLabel}  ${workingSet.root.path}`);
+    const availableStores = workingSet.members.filter((member) => member.role === 'referenced_store' && isAvailableMember(member));
+    const unavailable = workingSet.members.filter((member) => !isAvailableMember(member));
+    if (availableStores.length > 0) {
+        console.log('');
+        console.log('Referenced stores');
+        for (const member of availableStores) {
+            console.log(memberLine(member));
+            if (member.fetch) {
+                console.log(`    Fetch: ${member.fetch}`);
+            }
+        }
+    }
+    if (workingSet.members.length === 0) {
+        console.log('');
+        // Self-references are silently omitted from the index; an
+        // emptied-by-omission set must not claim nothing was declared.
+        console.log(declaredReferenceCount > 0
+            ? 'Declared references all resolve to this root; the working set is this root alone.'
+            : 'No references declared; the working set is this root alone.');
+    }
+    if (unavailable.length > 0 || workingSet.status.length > 0) {
+        console.log('');
+        console.log('Not available on this machine');
+        for (const member of unavailable) {
+            if (member.status.length === 0) {
+                console.log(`  - ${member.id}`);
+                continue;
+            }
+            for (const diagnostic of member.status) {
+                console.log(`  - ${member.id}: ${diagnostic.message}`);
+                if (diagnostic.fix) {
+                    console.log(`    Fix: ${diagnostic.fix}`);
+                }
+            }
+        }
+        for (const diagnostic of workingSet.status) {
+            console.log(`  Note: ${diagnostic.message}`);
+            if (diagnostic.fix) {
+                console.log(`  Fix: ${diagnostic.fix}`);
+            }
+        }
+    }
+}
+function writeCodeWorkspace(workingSet, outputPath, force) {
+    const resolved = path.resolve(outputPath);
+    if (fs.existsSync(resolved) && !force) {
+        throw new StoreError(`Refusing to overwrite ${resolved}.`, 'context_file_exists', {
+            target: 'context.output',
+            fix: `Pass --force to overwrite, or choose a different path.`,
+        });
+    }
+    const parent = path.dirname(resolved);
+    if (!fs.existsSync(parent)) {
+        throw new StoreError(`Output directory does not exist: ${parent}.`, 'context_output_dir_missing', { target: 'context.output', fix: 'Create the directory first, or choose another path.' });
+    }
+    const rootName = workingSet.root.store_id ?? path.basename(workingSet.root.path);
+    fs.writeFileSync(resolved, buildCodeWorkspaceJson(workingSet, rootName));
+    const available = workingSet.members.filter(isAvailableMember).length;
+    const skipped = workingSet.members
+        .filter((member) => !isAvailableMember(member))
+        .map((member) => member.id);
+    const summary = skipped.length > 0
+        ? `Wrote ${resolved} (${available + 1} folders; not available: ${skipped.join(', ')})`
+        : `Wrote ${resolved} (${available + 1} folders)`;
+    // stderr keeps JSON stdout pure; for humans it reads inline.
+    console.error(summary);
+}
+export function registerContextCommand(program) {
+    const description = COMMAND_REGISTRY.find((entry) => entry.name === 'context')?.description ??
+        'Print the working context for the resolved OpenSpec root';
+    program
+        .command('context')
+        .description(description)
+        .option('--store <id>', COMMON_FLAGS.store.description)
+        .addOption(new Option('--store-path <path>', 'Removed; register the store and use --store').hideHelp())
+        .option('--json', 'Output the agent brief as JSON')
+        .option('--code-workspace <path>', 'Also write a VS Code workspace file for the set')
+        .option('--force', 'Overwrite an existing --code-workspace file')
+        .action(async (options) => {
+        try {
+            const root = await resolveRootForCommand({ store: options.store, storePath: options.storePath }, { json: options.json, failurePayload: FAILURE_PAYLOAD, allowImplicitRoot: false });
+            if (!root) {
+                return;
+            }
+            const { workingSet, declaredReferenceCount } = await gatherWorkingSet(root);
+            if (options.json) {
+                // The write runs FIRST: a write failure must leave stdout
+                // holding exactly one JSON document (the failure payload).
+                if (options.codeWorkspace) {
+                    writeCodeWorkspace(workingSet, options.codeWorkspace, options.force === true);
+                }
+                printJson(workingSet);
+            }
+            else {
+                printHumanWorkingSet(workingSet, declaredReferenceCount);
+                if (options.codeWorkspace) {
+                    writeCodeWorkspace(workingSet, options.codeWorkspace, options.force === true);
+                }
+            }
+        }
+        catch (error) {
+            emitFailure(options.json, FAILURE_PAYLOAD, error, 'context_failed');
+        }
+    });
+}
+//# sourceMappingURL=context.js.map

package/dist/commands/doctor.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `openspec doctor` (slice 3.6): the root-scoped relationship-health
+ * report. Read-only — it answers "are the roots this work relates to
+ * available on this machine?" and never clones, syncs, or repairs.
+ */
+import { Command } from 'commander';
+export declare function registerDoctorCommand(program: Command): void;
+//# sourceMappingURL=doctor.d.ts.map

package/dist/commands/doctor.js

@@ -0,0 +1,163 @@
+/**
+ * `openspec doctor` (slice 3.6): the root-scoped relationship-health
+ * report. Read-only — it answers "are the roots this work relates to
+ * available on this machine?" and never clones, syncs, or repairs.
+ */
+import { Option } from 'commander';
+import { resolveRootForCommand, } from '../core/root-selection.js';
+import { readOptionalStoreMetadataState } from '../core/store/foundation.js';
+import { gitOriginUrl, isGitRepositoryAtRoot } from '../core/store/git.js';
+import { classifyOpenSpecDir, readProjectConfig, resolveConfigFilePath, } from '../core/project-config.js';
+import { findRepoPlanningRootSync } from '../core/planning-home.js';
+import { gatherRelationshipData } from './shared-gather.js';
+import { inspectRelationships, } from '../core/relationship-health.js';
+import { COMMAND_REGISTRY } from '../core/completions/command-registry.js';
+import { COMMON_FLAGS } from '../core/completions/shared-flags.js';
+import { emitFailure, printJson } from './shared-output.js';
+import * as path from 'node:path';
+const FAILURE_PAYLOAD = { root: null, store: null, references: [] };
+async function gatherHealth(root) {
+    const data = await gatherRelationshipData(root);
+    const { registrySnapshot, projectConfig, referenceEntries, rootInspection, } = data;
+    const registryUnreadable = registrySnapshot.unreadable;
+    const input = {
+        root,
+        rootHealthy: rootInspection.healthy,
+        rootStatus: rootInspection.diagnostics,
+        referenceEntries,
+        registryUnreadable,
+    };
+    // Store facts for store-backed roots (explicit --store or declared).
+    // Missing/invalid metadata never reaches here: store resolution
+    // verifies identity first and fails with the existing taxonomy
+    // (recorded amendment - corrupt store.yaml is an exit-1 resolution
+    // failure, not a health finding).
+    if (root.storeId) {
+        const metadata = await readOptionalStoreMetadataState(root.path).catch(() => null);
+        // git -C walks UP the tree: probing a non-repo store nested inside
+        // another repo would record the ENCLOSING repo's origin.
+        const originUrl = (await isGitRepositoryAtRoot(root.path)) ? await gitOriginUrl(root.path) : null;
+        input.storeFacts = {
+            id: root.storeId,
+            metadataPresent: metadata !== null,
+            metadataValid: metadata !== null,
+            ...(metadata?.remote ? { canonicalRemote: metadata.remote } : {}),
+            ...(originUrl ? { originUrl } : {}),
+        };
+    }
+    // The 3.2 both-shapes wrong turn, structured — including a malformed
+    // pointer value, which the resolver is silent about on planning-shaped
+    // roots.
+    if (root.source === 'nearest') {
+        const { hasPlanningShape, pointer } = classifyOpenSpecDir(root.path);
+        if (hasPlanningShape && pointer.filePath) {
+            if (pointer.value !== undefined) {
+                input.bothShapesPointer = { value: pointer.value, filePath: pointer.filePath };
+            }
+            else if (pointer.malformed) {
+                input.malformedPointer = { filePath: pointer.filePath, reason: pointer.malformed };
+            }
+        }
+    }
+    // The 3.4-recorded inert-pointer wrong turn: the resolved root is the
+    // STORE; re-walk to the pointer directory and read ITS config.
+    if (root.source === 'declared') {
+        const pointerRoot = findRepoPlanningRootSync(process.cwd());
+        if (pointerRoot) {
+            const pointerConfig = readProjectConfig(pointerRoot);
+            const fields = [];
+            if (pointerConfig?.references?.length)
+                fields.push('references');
+            if (fields.length > 0) {
+                const filePath = resolveConfigFilePath(pointerRoot) ??
+                    path.join(pointerRoot, 'openspec', 'config.yaml');
+                input.inertPointerDeclarations = { filePath, fields };
+            }
+        }
+    }
+    return {
+        health: inspectRelationships(input),
+        declaredReferenceCount: projectConfig?.references?.length ?? 0,
+    };
+}
+function printDiagnosticLines(prefix, status) {
+    for (const entry of status) {
+        console.log(`${prefix}- ${entry.message}`);
+        if (entry.fix) {
+            console.log(`${prefix}  Fix: ${entry.fix}`);
+        }
+    }
+}
+function printEntrySection(title, entries, emptyLine, okLine, idOf) {
+    console.log('');
+    console.log(title);
+    if (entries.length === 0) {
+        console.log(`  ${emptyLine}`);
+        return;
+    }
+    for (const entry of entries) {
+        if (entry.status.length === 0) {
+            console.log(`  - ${okLine(entry)}`);
+            continue;
+        }
+        for (const diagnostic of entry.status) {
+            console.log(`  - ${idOf(entry)}: ${diagnostic.message}`);
+            if (diagnostic.fix) {
+                console.log(`    Fix: ${diagnostic.fix}`);
+            }
+        }
+    }
+}
+function printHumanHealth(health, declaredReferenceCount) {
+    console.log('Doctor');
+    console.log('');
+    console.log('Root');
+    console.log(`  Location: ${health.root.path}`);
+    console.log(`  OpenSpec root: ${health.root.healthy ? 'ok' : 'unhealthy'}`);
+    if (health.store) {
+        const metadataNote = health.store.metadata.valid ? 'metadata ok' : 'metadata invalid';
+        console.log(`  Store: ${health.store.id} (${metadataNote})`);
+    }
+    printDiagnosticLines('  ', [...health.root.status, ...(health.store?.status ?? [])]);
+    // "(none declared)" must never lie: self-references are omitted from
+    // the index, so an emptied-by-omission list gets its own line.
+    const referencesEmptyLine = health.references.length === 0 && declaredReferenceCount > 0
+        ? '(declared references all resolve to this root)'
+        : '(none declared)';
+    printEntrySection('References', health.references, referencesEmptyLine, (entry) => `${entry.store_id}: ok${entry.root ? ` (${entry.root})` : ''}`, (entry) => entry.store_id);
+    for (const entry of health.status) {
+        console.log('');
+        console.log(`Note: ${entry.message}`);
+        if (entry.fix) {
+            console.log(`Fix: ${entry.fix}`);
+        }
+    }
+}
+export function registerDoctorCommand(program) {
+    const description = COMMAND_REGISTRY.find((entry) => entry.name === 'doctor')?.description ??
+        'Report relationship health for the resolved OpenSpec root';
+    program
+        .command('doctor')
+        .description(description)
+        .option('--store <id>', COMMON_FLAGS.store.description)
+        .addOption(new Option('--store-path <path>', 'Removed; register the store and use --store').hideHelp())
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            const root = await resolveRootForCommand({ store: options.store, storePath: options.storePath }, { json: options.json, failurePayload: FAILURE_PAYLOAD, allowImplicitRoot: false });
+            if (!root) {
+                return;
+            }
+            const { health, declaredReferenceCount } = await gatherHealth(root);
+            if (options.json) {
+                printJson(health);
+                return;
+            }
+            printHumanHealth(health, declaredReferenceCount);
+        }
+        catch (error) {
+            emitFailure(options.json, FAILURE_PAYLOAD, error, 'doctor_failed');
+        }
+    });
+}
+//# sourceMappingURL=doctor.js.map

package/dist/commands/feedback.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Feedback command implementation
+ */
+export declare class FeedbackCommand {
+    execute(message: string, options?: {
+        body?: string;
+    }): Promise<void>;
+}
+//# sourceMappingURL=feedback.d.ts.map

package/dist/commands/feedback.js

@@ -0,0 +1,183 @@
+import { execSync, execFileSync } from 'child_process';
+import { createRequire } from 'module';
+import os from 'os';
+const require = createRequire(import.meta.url);
+/**
+ * Check if gh CLI is installed and available in PATH
+ * Uses platform-appropriate command: 'where' on Windows, 'which' on Unix/macOS
+ */
+function isGhInstalled() {
+    try {
+        const command = process.platform === 'win32' ? 'where gh' : 'which gh';
+        execSync(command, { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if gh CLI is authenticated
+ */
+function isGhAuthenticated() {
+    try {
+        execSync('gh auth status', { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get OpenSpec version from package.json
+ */
+function getVersion() {
+    try {
+        const { version } = require('../../package.json');
+        return version;
+    }
+    catch {
+        return 'unknown';
+    }
+}
+/**
+ * Get platform name
+ */
+function getPlatform() {
+    return os.platform();
+}
+/**
+ * Get current timestamp in ISO format
+ */
+function getTimestamp() {
+    return new Date().toISOString();
+}
+/**
+ * Generate metadata footer for feedback
+ */
+function generateMetadata() {
+    const version = getVersion();
+    const platform = getPlatform();
+    const timestamp = getTimestamp();
+    return `---
+Submitted via OpenSpec CLI
+- Version: ${version}
+- Platform: ${platform}
+- Timestamp: ${timestamp}`;
+}
+/**
+ * Format the feedback title
+ */
+function formatTitle(message) {
+    return `Feedback: ${message}`;
+}
+/**
+ * Format the full feedback body
+ */
+function formatBody(bodyText) {
+    const parts = [];
+    if (bodyText) {
+        parts.push(bodyText);
+        parts.push(''); // Empty line before metadata
+    }
+    parts.push(generateMetadata());
+    return parts.join('\n');
+}
+/**
+ * Generate a pre-filled GitHub issue URL for manual submission
+ */
+function generateManualSubmissionUrl(title, body) {
+    const repo = 'Fission-AI/OpenSpec';
+    const encodedTitle = encodeURIComponent(title);
+    const encodedBody = encodeURIComponent(body);
+    const encodedLabels = encodeURIComponent('feedback');
+    return `https://github.com/${repo}/issues/new?title=${encodedTitle}&body=${encodedBody}&labels=${encodedLabels}`;
+}
+/**
+ * Display formatted feedback content for manual submission
+ */
+function displayFormattedFeedback(title, body) {
+    console.log('\n--- FORMATTED FEEDBACK ---');
+    console.log(`Title: ${title}`);
+    console.log(`Labels: feedback`);
+    console.log('\nBody:');
+    console.log(body);
+    console.log('--- END FEEDBACK ---\n');
+}
+/**
+ * Submit feedback via gh CLI
+ * Uses execFileSync to prevent shell injection vulnerabilities
+ */
+function submitViaGhCli(title, body) {
+    try {
+        const result = execFileSync('gh', [
+            'issue',
+            'create',
+            '--repo',
+            'Fission-AI/OpenSpec',
+            '--title',
+            title,
+            '--body',
+            body,
+            '--label',
+            'feedback',
+        ], { encoding: 'utf-8', stdio: 'pipe' });
+        const issueUrl = result.trim();
+        console.log(`\n✓ Feedback submitted successfully!`);
+        console.log(`Issue URL: ${issueUrl}\n`);
+    }
+    catch (error) {
+        // Display the error output from gh CLI
+        if (error.stderr) {
+            console.error(error.stderr.toString());
+        }
+        else if (error.message) {
+            console.error(error.message);
+        }
+        // Exit with the same code as gh CLI
+        process.exit(error.status ?? 1);
+    }
+}
+/**
+ * Handle fallback when gh CLI is not available or not authenticated
+ */
+function handleFallback(title, body, reason) {
+    if (reason === 'missing') {
+        console.log('⚠️  GitHub CLI not found. Manual submission required.');
+    }
+    else {
+        console.log('⚠️  GitHub authentication required. Manual submission required.');
+    }
+    displayFormattedFeedback(title, body);
+    const manualUrl = generateManualSubmissionUrl(title, body);
+    console.log('Please submit your feedback manually:');
+    console.log(manualUrl);
+    if (reason === 'unauthenticated') {
+        console.log('\nTo auto-submit in the future: gh auth login');
+    }
+    // Exit with success code (fallback is successful)
+    process.exit(0);
+}
+/**
+ * Feedback command implementation
+ */
+export class FeedbackCommand {
+    async execute(message, options) {
+        // Format title and body once for all code paths
+        const title = formatTitle(message);
+        const body = formatBody(options?.body);
+        // Check if gh CLI is installed
+        if (!isGhInstalled()) {
+            handleFallback(title, body, 'missing');
+            return;
+        }
+        // Check if gh CLI is authenticated
+        if (!isGhAuthenticated()) {
+            handleFallback(title, body, 'unauthenticated');
+            return;
+        }
+        // Submit via gh CLI
+        submitViaGhCli(title, body);
+    }
+}
+//# sourceMappingURL=feedback.js.map

package/dist/commands/schema.d.ts

@@ -0,0 +1,6 @@
+import { Command } from 'commander';
+/**
+ * Register the schema command and all its subcommands.
+ */
+export declare function registerSchemaCommand(program: Command): void;
+//# sourceMappingURL=schema.d.ts.map