gmc-openspec 1.0.0

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/jira.d.ts

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

package/dist/commands/jira.js

@@ -0,0 +1,249 @@
+import { createRequire } from 'module';
+import path from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+import { getGlobalConfig } from '../core/global-config.js';
+import { getAllowedNext, readJiraIntake, runJiraDoctor, setupJiraIntegration, validateJiraId, validateJiraIntake, } from '../core/jira/index.js';
+const require = createRequire(import.meta.url);
+const { version: OPENSPEC_VERSION } = require('../../package.json');
+const VALID_STAGES = new Set(['source', 'requirement', 'stories', 'propose']);
+export function registerJiraCommand(program) {
+    const jiraCmd = program
+        .command('jira')
+        .description('Manage Jira intake setup, validation, and status');
+    jiraCmd
+        .command('setup [path]')
+        .description('Set up Jira intake configuration and AI workflow artifacts')
+        .option('--tools <tools>', 'AI tools to configure: all, none, detected, or comma-separated tool IDs', 'detected')
+        .option('--provider <provider>', 'Jira provider (V1 supports atlassian-rovo)', 'atlassian-rovo')
+        .option('--endpoint <url>', 'Atlassian MCP endpoint')
+        .option('--force', 'Overwrite existing Jira setup files when needed')
+        .option('--json', 'Output setup result as JSON')
+        .action(async (targetPath = '.', options) => {
+        const spinner = options?.json ? undefined : ora('Setting up Jira intake...').start();
+        try {
+            const projectRoot = path.resolve(targetPath);
+            const globalConfig = getGlobalConfig();
+            const result = await setupJiraIntegration(projectRoot, {
+                tools: options?.tools,
+                provider: options?.provider,
+                endpoint: options?.endpoint,
+                force: options?.force,
+                delivery: globalConfig.delivery ?? 'both',
+                generatedByVersion: OPENSPEC_VERSION,
+            });
+            spinner?.succeed('Jira intake setup complete');
+            if (options?.json) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                printSetupResult(result);
+            }
+        }
+        catch (error) {
+            spinner?.fail('Jira intake setup failed');
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exitCode = 1;
+        }
+    });
+    jiraCmd
+        .command('doctor [path]')
+        .description('Check Jira intake configuration and local MCP prerequisites')
+        .option('--json', 'Output doctor report as JSON')
+        .action((targetPath = '.', options) => {
+        try {
+            const projectRoot = path.resolve(targetPath);
+            const report = runJiraDoctor(projectRoot);
+            if (options?.json) {
+                console.log(JSON.stringify(report, null, 2));
+            }
+            else {
+                printDoctorReport(report);
+            }
+            if (!report.ok)
+                process.exitCode = 1;
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exitCode = 1;
+        }
+    });
+    jiraCmd
+        .command('validate <jira-id>')
+        .description('Validate a Jira intake folder before moving to the next stage')
+        .option('--stage <stage>', 'Validation stage: source, requirement, stories, propose', 'source')
+        .option('--json', 'Output validation report as JSON')
+        .action((jiraId, options) => {
+        try {
+            const stage = normalizeStage(options?.stage);
+            const report = validateJiraIntake(process.cwd(), jiraId, stage);
+            if (options?.json) {
+                console.log(JSON.stringify(report, null, 2));
+            }
+            else {
+                printValidationReport(report);
+            }
+            if (!report.ok)
+                process.exitCode = 1;
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exitCode = 1;
+        }
+    });
+    jiraCmd
+        .command('status <jira-id>')
+        .description('Show Jira intake status and allowed next states')
+        .option('--json', 'Output status as JSON')
+        .action((jiraId, options) => {
+        try {
+            const idValidation = validateJiraId(jiraId);
+            if (!idValidation.valid) {
+                throw new Error(idValidation.error);
+            }
+            const intakeResult = readJiraIntake(process.cwd(), jiraId);
+            const status = intakeResult.intake?.status;
+            const blockingStage = status ? getStatusBlockingStage(status) : undefined;
+            const blockingValidation = blockingStage ? validateJiraIntake(process.cwd(), jiraId, blockingStage) : undefined;
+            const result = {
+                ok: intakeResult.intake != null,
+                jira: jiraId.toUpperCase(),
+                issueDir: intakeResult.issueDir,
+                intakePath: intakeResult.path,
+                status,
+                allowedNext: status ? getAllowedNext(status) : [],
+                nextCommands: status ? getNextCommands(status, jiraId.toUpperCase()) : [],
+                blockingStage,
+                blockingItems: blockingValidation?.errors ?? [],
+                warnings: intakeResult.warnings,
+            };
+            if (options?.json) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                printStatusResult(result);
+            }
+            if (!result.ok)
+                process.exitCode = 1;
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            process.exitCode = 1;
+        }
+    });
+}
+function normalizeStage(stage) {
+    const normalized = stage ?? 'source';
+    if (!VALID_STAGES.has(normalized)) {
+        throw new Error(`Invalid stage "${normalized}". Expected one of: ${[...VALID_STAGES].join(', ')}`);
+    }
+    return normalized;
+}
+function printSetupResult(result) {
+    console.log();
+    console.log(chalk.bold('Jira Intake Setup'));
+    console.log(`Config: ${result.configPath}`);
+    console.log(`Provider: ${result.config.provider}`);
+    console.log(`Endpoint: ${result.config.endpoint}`);
+    console.log(`Tools: ${result.tools.length > 0 ? result.tools.join(', ') : 'none'}`);
+    console.log(`Artifacts: ${result.skillsWritten} skills, ${result.commandsWritten} commands`);
+    printMcpConfigResults(result.mcpConfigResults);
+    if (result.commandsSkipped.length > 0) {
+        console.log(chalk.dim(`Commands skipped for: ${result.commandsSkipped.join(', ')} (no adapter)`));
+    }
+    console.log();
+    console.log(chalk.bold('MCP snippet'));
+    console.log(result.tools.length > 0 ? Object.values(result.snippets)[0] : 'Configure your AI client with an Atlassian MCP server before importing Jira tickets.');
+    console.log();
+    console.log('Next: restart your AI client, then run /opsx:jira-import ABC-123.');
+}
+function printMcpConfigResults(results) {
+    if (results.length === 0) {
+        return;
+    }
+    const summary = results.map((result) => `${result.toolId}: ${result.status}`).join(', ');
+    console.log(`MCP configs: ${summary}`);
+    for (const result of results) {
+        if (result.status === 'unsupported' || result.status === 'invalid-json') {
+            console.log(chalk.yellow(`MCP ${result.toolId}: ${result.message}`));
+        }
+    }
+}
+function printDoctorReport(report) {
+    console.log(chalk.bold('Jira Intake Doctor'));
+    for (const check of report.checks) {
+        const symbol = check.level === 'ok' ? chalk.green('✓') : check.level === 'error' ? chalk.red('✗') : chalk.yellow('!');
+        console.log(`${symbol} ${check.message}`);
+        if (check.details) {
+            console.log(chalk.dim(check.details));
+        }
+    }
+    console.log();
+    console.log(chalk.bold('AI client test prompt'));
+    console.log(report.testPrompt);
+}
+function printValidationReport(report) {
+    const status = report.ok ? chalk.green('valid') : chalk.red('invalid');
+    console.log(`Jira intake ${report.jira} (${report.stage}): ${status}`);
+    console.log(`Folder: ${report.issueDir}`);
+    if (report.status)
+        console.log(`Status: ${report.status}`);
+    for (const warning of report.warnings) {
+        console.log(chalk.yellow(`Warning [${warning.code}]: ${warning.message}${warning.file ? ` (${warning.file})` : ''}`));
+    }
+    for (const error of report.errors) {
+        console.log(chalk.red(`Error [${error.code}]: ${error.message}${error.file ? ` (${error.file})` : ''}`));
+    }
+}
+function printStatusResult(result) {
+    if (!result.ok) {
+        console.log(chalk.red(`No Jira intake found for ${result.jira}. Run /opsx:jira-import ${result.jira} first.`));
+        console.log(chalk.dim(`Expected: ${result.intakePath}`));
+        return;
+    }
+    console.log(chalk.bold(`Jira Intake ${result.jira}`));
+    console.log(`Status: ${result.status}`);
+    console.log(`Folder: ${result.issueDir}`);
+    console.log(`Allowed next: ${result.allowedNext.length > 0 ? result.allowedNext.join(', ') : 'none'}`);
+    const richResult = result;
+    console.log(`Next commands: ${richResult.nextCommands && richResult.nextCommands.length > 0 ? richResult.nextCommands.join(', ') : 'none'}`);
+    if (richResult.blockingStage) {
+        console.log(`Blocking check: ${richResult.blockingStage}`);
+    }
+    if (richResult.blockingItems && richResult.blockingItems.length > 0) {
+        for (const item of richResult.blockingItems) {
+            console.log(chalk.red(`Blocker [${item.code}]: ${item.message}${item.file ? ` (${item.file})` : ''}`));
+        }
+    }
+    for (const warning of result.warnings) {
+        console.log(chalk.yellow(`Warning: ${warning}`));
+    }
+}
+function getStatusBlockingStage(status) {
+    if (status === 'imported')
+        return 'source';
+    if (status === 'refining' || status === 'ready-for-review' || status === 'reviewed')
+        return 'requirement';
+    if (status === 'split' || status === 'stories-reviewed')
+        return 'stories';
+    return 'propose';
+}
+function getNextCommands(status, jiraId) {
+    switch (status) {
+        case 'imported':
+        case 'refining':
+            return [`/opsx:jira-refine ${jiraId}`];
+        case 'ready-for-review':
+            return [`/opsx:jira-review ${jiraId}`];
+        case 'reviewed':
+        case 'split':
+            return [`/opsx:jira-split ${jiraId}`];
+        case 'stories-reviewed':
+            return [`/opsx:jira-propose ${jiraId}`];
+        case 'proposed':
+            return [`/opsx:jira-sync ${jiraId}`];
+        case 'synced':
+            return [];
+    }
+}
+//# sourceMappingURL=jira.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