openspec-cn 0.23.0

package/dist/commands/config.js

@@ -0,0 +1,198 @@
+import { spawn } from 'node:child_process';
+import * as fs from 'node:fs';
+import { getGlobalConfigPath, getGlobalConfig, saveGlobalConfig, } from '../core/global-config.js';
+import { getNestedValue, setNestedValue, deleteNestedValue, coerceValue, formatValueYaml, validateConfigKeyPath, validateConfig, DEFAULT_CONFIG, } from '../core/config-schema.js';
+/**
+ * Register the config command and all its subcommands.
+ *
+ * @param program - The Commander program instance
+ */
+export function registerConfigCommand(program) {
+    const configCmd = program
+        .command('config')
+        .description('View and modify global OpenSpec configuration')
+        .option('--scope <scope>', 'Config scope (only "global" supported currently)')
+        .hook('preAction', (thisCommand) => {
+        const opts = thisCommand.opts();
+        if (opts.scope && opts.scope !== 'global') {
+            console.error('Error: Project-local config is not yet implemented');
+            process.exit(1);
+        }
+    });
+    // config path
+    configCmd
+        .command('path')
+        .description('Show config file location')
+        .action(() => {
+        console.log(getGlobalConfigPath());
+    });
+    // config list
+    configCmd
+        .command('list')
+        .description('Show all current settings')
+        .option('--json', 'Output as JSON')
+        .action((options) => {
+        const config = getGlobalConfig();
+        if (options.json) {
+            console.log(JSON.stringify(config, null, 2));
+        }
+        else {
+            console.log(formatValueYaml(config));
+        }
+    });
+    // config get
+    configCmd
+        .command('get <key>')
+        .description('Get a specific value (raw, scriptable)')
+        .action((key) => {
+        const config = getGlobalConfig();
+        const value = getNestedValue(config, key);
+        if (value === undefined) {
+            process.exitCode = 1;
+            return;
+        }
+        if (typeof value === 'object' && value !== null) {
+            console.log(JSON.stringify(value));
+        }
+        else {
+            console.log(String(value));
+        }
+    });
+    // config set
+    configCmd
+        .command('set <key> <value>')
+        .description('Set a value (auto-coerce types)')
+        .option('--string', 'Force value to be stored as string')
+        .option('--allow-unknown', 'Allow setting unknown keys')
+        .action((key, value, options) => {
+        const allowUnknown = Boolean(options.allowUnknown);
+        const keyValidation = validateConfigKeyPath(key);
+        if (!keyValidation.valid && !allowUnknown) {
+            const reason = keyValidation.reason ? ` ${keyValidation.reason}.` : '';
+            console.error(`Error: Invalid configuration key "${key}".${reason}`);
+            console.error('Use "openspec config list" to see available keys.');
+            console.error('Pass --allow-unknown to bypass this check.');
+            process.exitCode = 1;
+            return;
+        }
+        const config = getGlobalConfig();
+        const coercedValue = coerceValue(value, options.string || false);
+        // Create a copy to validate before saving
+        const newConfig = JSON.parse(JSON.stringify(config));
+        setNestedValue(newConfig, key, coercedValue);
+        // Validate the new config
+        const validation = validateConfig(newConfig);
+        if (!validation.success) {
+            console.error(`Error: Invalid configuration - ${validation.error}`);
+            process.exitCode = 1;
+            return;
+        }
+        // Apply changes and save
+        setNestedValue(config, key, coercedValue);
+        saveGlobalConfig(config);
+        const displayValue = typeof coercedValue === 'string' ? `"${coercedValue}"` : String(coercedValue);
+        console.log(`Set ${key} = ${displayValue}`);
+    });
+    // config unset
+    configCmd
+        .command('unset <key>')
+        .description('Remove a key (revert to default)')
+        .action((key) => {
+        const config = getGlobalConfig();
+        const existed = deleteNestedValue(config, key);
+        if (existed) {
+            saveGlobalConfig(config);
+            console.log(`Unset ${key} (reverted to default)`);
+        }
+        else {
+            console.log(`Key "${key}" was not set`);
+        }
+    });
+    // config reset
+    configCmd
+        .command('reset')
+        .description('Reset configuration to defaults')
+        .option('--all', 'Reset all configuration (required)')
+        .option('-y, --yes', 'Skip confirmation prompts')
+        .action(async (options) => {
+        if (!options.all) {
+            console.error('Error: --all flag is required for reset');
+            console.error('Usage: openspec config reset --all [-y]');
+            process.exitCode = 1;
+            return;
+        }
+        if (!options.yes) {
+            const { confirm } = await import('@inquirer/prompts');
+            const confirmed = await confirm({
+                message: 'Reset all configuration to defaults?',
+                default: false,
+            });
+            if (!confirmed) {
+                console.log('Reset cancelled.');
+                return;
+            }
+        }
+        saveGlobalConfig({ ...DEFAULT_CONFIG });
+        console.log('Configuration reset to defaults');
+    });
+    // config edit
+    configCmd
+        .command('edit')
+        .description('Open config in $EDITOR')
+        .action(async () => {
+        const editor = process.env.EDITOR || process.env.VISUAL;
+        if (!editor) {
+            console.error('Error: No editor configured');
+            console.error('Set the EDITOR or VISUAL environment variable to your preferred editor');
+            console.error('Example: export EDITOR=vim');
+            process.exitCode = 1;
+            return;
+        }
+        const configPath = getGlobalConfigPath();
+        // Ensure config file exists with defaults
+        if (!fs.existsSync(configPath)) {
+            saveGlobalConfig({ ...DEFAULT_CONFIG });
+        }
+        // Spawn editor and wait for it to close
+        // Avoid shell parsing to correctly handle paths with spaces in both
+        // the editor path and config path
+        const child = spawn(editor, [configPath], {
+            stdio: 'inherit',
+            shell: false,
+        });
+        await new Promise((resolve, reject) => {
+            child.on('close', (code) => {
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`Editor exited with code ${code}`));
+                }
+            });
+            child.on('error', reject);
+        });
+        try {
+            const rawConfig = fs.readFileSync(configPath, 'utf-8');
+            const parsedConfig = JSON.parse(rawConfig);
+            const validation = validateConfig(parsedConfig);
+            if (!validation.success) {
+                console.error(`Error: Invalid configuration - ${validation.error}`);
+                process.exitCode = 1;
+            }
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                console.error(`Error: Config file not found at ${configPath}`);
+            }
+            else if (error instanceof SyntaxError) {
+                console.error(`Error: Invalid JSON in ${configPath}`);
+                console.error(error.message);
+            }
+            else {
+                console.error(`Error: Unable to validate configuration - ${error instanceof Error ? error.message : String(error)}`);
+            }
+            process.exitCode = 1;
+        }
+    });
+}
+//# sourceMappingURL=config.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