gsd-opencode 1.9.1 → 1.10.1

package/src/commands/check.js

@@ -0,0 +1,329 @@
+/**
+ * Check command for GSD-OpenCode CLI.
+ *
+ * This module provides the check functionality to verify installation health,
+ * showing detailed pass/fail results for file existence, version matching,
+ * and file integrity checks.
+ *
+ * Implements requirements:
+ * - CLI-03: User can run gsd-opencode check to verify installation health
+ * - CHECK-01: Check verifies all required files exist
+ * - CHECK-02: Check verifies installed version matches expected version
+ * - CHECK-03: Check detects corrupted or modified files
+ * - CHECK-04: Check provides clear pass/fail output for each verification
+ * - CHECK-05: Check returns appropriate exit codes (0 for healthy, non-zero for issues)
+ * - ERROR-03: All commands support --verbose flag for detailed debugging output
+ * - ERROR-06: CLI shows consistent branding and formatted output using colors
+ *
+ * @module check
+ */
+
+import { ScopeManager } from '../services/scope-manager.js';
+import { HealthChecker } from '../services/health-checker.js';
+import { logger, setVerbose } from '../utils/logger.js';
+import { ERROR_CODES } from '../../lib/constants.js';
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+/**
+ * Gets the package version from package.json.
+ *
+ * @returns {Promise<string>} The package version
+ * @private
+ */
+async function getPackageVersion() {
+  try {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const packageRoot = path.resolve(__dirname, '../..');
+    const packageJsonPath = path.join(packageRoot, 'package.json');
+
+    const content = await fs.readFile(packageJsonPath, 'utf-8');
+    const pkg = JSON.parse(content);
+    return pkg.version || '1.0.0';
+  } catch (error) {
+    logger.warning('Could not read package version, using 1.0.0');
+    return '1.0.0';
+  }
+}
+
+/**
+ * Displays health check results with pass/fail indicators.
+ *
+ * @param {Object} results - Health check results from HealthChecker
+ * @param {string} scopeLabel - Label for this scope
+ * @private
+ */
+function displayCheckResults(results, scopeLabel) {
+  logger.heading(`${scopeLabel} Installation Health`);
+  logger.dim('================================');
+
+  if (!results) {
+    logger.info('Not installed');
+    logger.dim('');
+    return;
+  }
+
+  const { categories } = results;
+
+  // Files check section
+  logger.dim('');
+  logger.info('Required Files');
+  if (categories.files && categories.files.checks) {
+    for (const check of categories.files.checks) {
+      const status = check.passed ? 'OK' : (check.error || 'Missing');
+      if (check.passed) {
+        logger.success(`${check.name}: ${status}`);
+      } else {
+        logger.error(`${check.name}: ${status}`);
+      }
+    }
+  }
+
+  // Version check section
+  if (categories.version) {
+    logger.dim('');
+    logger.info('Version Verification');
+    const versionCheck = categories.version.checks[0];
+    if (versionCheck.passed) {
+      logger.success(`Version: ${versionCheck.installed} - OK`);
+    } else {
+      const errorMsg = versionCheck.error
+        ? `Version check failed - ${versionCheck.error}`
+        : `Version mismatch (installed: ${versionCheck.installed || 'none'}, expected: ${versionCheck.expected})`;
+      logger.error(errorMsg);
+    }
+  }
+
+  // Integrity check section
+  logger.dim('');
+  logger.info('File Integrity');
+  if (categories.integrity && categories.integrity.checks) {
+    for (const check of categories.integrity.checks) {
+      const relativePath = check.relative || path.basename(check.file);
+      const message = check.passed
+        ? `${relativePath} - OK`
+        : `${relativePath} - ${check.error || 'Corrupted or missing'}`;
+
+      if (check.passed) {
+        logger.success(message);
+      } else {
+        logger.error(message);
+      }
+    }
+  }
+
+  // Structure check section (NEW)
+  if (categories.structure) {
+    logger.dim('');
+    logger.info('Directory Structure');
+    const structure = categories.structure;
+    const statusText = structure.label;
+
+    if (structure.type === 'dual') {
+      logger.error(`${statusText} - Action required`);
+      logger.dim('  Both old (command/gsd/) and new (commands/gsd/) structures detected.');
+      logger.dim('  This can happen if an update was interrupted.');
+      logger.dim("  Run 'gsd-opencode update' to complete migration");
+    } else if (structure.needsMigration) {
+      logger.warning(`${statusText} - Migration recommended`);
+      logger.dim("  Run 'gsd-opencode update' to migrate to new structure");
+    } else if (structure.type === 'new') {
+      logger.success(`${statusText} - OK`);
+    } else if (structure.type === 'none') {
+      logger.info(`${statusText}`);
+    } else {
+      logger.info(statusText);
+    }
+  }
+
+  // Overall status
+  logger.dim('');
+  if (results.passed) {
+    logger.success('All checks passed - Installation is healthy');
+  } else {
+    logger.error('Some checks failed - Issues detected');
+  }
+  logger.dim('');
+}
+
+/**
+ * Checks health for a single scope.
+ *
+ * @param {string} scope - 'global' or 'local'
+ * @param {Object} options - Options
+ * @param {boolean} options.verbose - Enable verbose output
+ * @returns {Promise<Object>} Health check results
+ * @private
+ */
+async function checkScope(scope, options = {}) {
+  const scopeManager = new ScopeManager({ scope });
+  const scopeLabel = scope.charAt(0).toUpperCase() + scope.slice(1);
+
+  logger.debug(`Checking ${scope} installation...`);
+
+  const isInstalled = await scopeManager.isInstalled();
+  if (!isInstalled) {
+    logger.debug(`No ${scope} installation found`);
+    return {
+      installed: false,
+      scope,
+      scopeLabel,
+      results: null,
+      passed: false
+    };
+  }
+
+  logger.debug(`${scope} installation detected, running health checks...`);
+
+  const healthChecker = new HealthChecker(scopeManager);
+  const expectedVersion = await getPackageVersion();
+
+  try {
+    const results = await healthChecker.checkAll({
+      expectedVersion,
+      verbose: options.verbose
+    });
+
+    return {
+      installed: true,
+      scope,
+      scopeLabel,
+      results,
+      passed: results.passed
+    };
+  } catch (error) {
+    logger.debug(`Error during health check: ${error.message}`);
+    return {
+      installed: true,
+      scope,
+      scopeLabel,
+      results: null,
+      passed: false,
+      error: error.message
+    };
+  }
+}
+
+/**
+ * Handles errors with helpful messages.
+ *
+ * @param {Error} error - The error to handle
+ * @param {boolean} verbose - Whether verbose mode is enabled
+ * @returns {number} Exit code for the error
+ * @private
+ */
+function handleError(error, verbose) {
+  if (verbose) {
+    logger.debug(`Error details: ${error.stack || error.message}`);
+    logger.debug(`Error code: ${error.code}`);
+  }
+
+  if (error.code === 'EACCES') {
+    logger.error('Permission denied: Cannot access installation directory');
+    logger.dim('');
+    logger.dim('Suggestion: Check directory permissions or run with appropriate privileges.');
+    return ERROR_CODES.PERMISSION_ERROR;
+  }
+
+  logger.error(`Failed to check installation health: ${error.message}`);
+
+  if (!verbose) {
+    logger.dim('');
+    logger.dim('Suggestion: Run with --verbose for detailed error information');
+  }
+
+  return ERROR_CODES.GENERAL_ERROR;
+}
+
+/**
+ * Main check command function.
+ *
+ * @param {Object} options - Command options
+ * @param {boolean} [options.global] - Check global installation only
+ * @param {boolean} [options.local] - Check local installation only
+ * @param {boolean} [options.verbose] - Enable verbose output
+ * @returns {Promise<number>} Exit code
+ */
+export async function checkCommand(options = {}) {
+  const verbose = options.verbose || false;
+  setVerbose(verbose);
+
+  logger.debug('Starting check command');
+  logger.debug(`Options: global=${options.global}, local=${options.local}, verbose=${verbose}`);
+
+  try {
+    logger.heading('GSD-OpenCode Installation Health');
+    logger.dim('================================');
+
+    const scopesToCheck = [];
+    if (options.global) {
+      scopesToCheck.push('global');
+    } else if (options.local) {
+      scopesToCheck.push('local');
+    } else {
+      scopesToCheck.push('global', 'local');
+    }
+
+    let anyInstalled = false;
+    let allPassed = true;
+
+    for (const scope of scopesToCheck) {
+      try {
+        const result = await checkScope(scope, options);
+
+        if (result.installed) {
+          anyInstalled = true;
+          if (!result.passed) {
+            allPassed = false;
+          }
+        }
+
+        if (scopesToCheck.length > 1) {
+          logger.dim('');
+        }
+
+        displayCheckResults(result.results, result.scopeLabel);
+
+        if (verbose && result.error) {
+          logger.debug(`Error checking ${scope}: ${result.error}`);
+        }
+      } catch (error) {
+        logger.error(`Failed to check ${scope} installation: ${error.message}`);
+        allPassed = false;
+
+        if (verbose) {
+          logger.debug(error.stack);
+        }
+      }
+    }
+
+    if (!anyInstalled) {
+      logger.dim('');
+      logger.dim('Not installed anywhere');
+      logger.dim('');
+      logger.info("Run 'gsd-opencode install' to install");
+      logger.dim('');
+      return ERROR_CODES.SUCCESS;
+    }
+
+    const exitCode = allPassed ? ERROR_CODES.SUCCESS : ERROR_CODES.GENERAL_ERROR;
+
+    if (verbose) {
+      logger.debug(`Check complete. Exit code: ${exitCode}`);
+    }
+
+    return exitCode;
+
+  } catch (error) {
+    if (error.name === 'AbortPromptError' || error.message?.includes('cancel')) {
+      logger.info('Command cancelled by user');
+      return ERROR_CODES.INTERRUPTED;
+    }
+
+    return handleError(error, verbose);
+  }
+}
+
+export default checkCommand;

package/src/commands/config.js

@@ -0,0 +1,337 @@
+/**
+ * Config command for GSD-OpenCode CLI.
+ *
+ * This module provides configuration management with subcommands for getting,
+ * setting, resetting, and listing configuration values. Supports value auto-parsing
+ * (booleans, numbers, JSON strings) and multiple output formats (human-readable and JSON).
+ *
+ * Implements requirements:
+ * - CLI-07: User can run gsd-opencode config to manage settings
+ * - CONFIG-01: Config get <key> returns value (or error if not set)
+ * - CONFIG-02: Config set <key> <value> parses booleans, numbers, JSON
+ * - CONFIG-03: Config reset <key> restores default
+ * - CONFIG-04: Config reset --all removes entire config
+ * - CONFIG-05: Config list shows all settings
+ * - CONFIG-06: Config list --json outputs valid JSON
+ * - ERROR-03: All commands support --verbose flag for detailed debugging output
+ *
+ * @module commands/config
+ * @description Configuration management command for GSD-OpenCode
+ */
+
+import { SettingsManager } from '../services/settings.js';
+import { logger, setVerbose } from '../utils/logger.js';
+import { ERROR_CODES } from '../../lib/constants.js';
+
+/**
+ * Flattens a nested object using dot-notation keys.
+ *
+ * Recursively traverses an object and creates flat key-value pairs
+ * where nested keys are joined with dots (e.g., 'ui.colors').
+ *
+ * @param {Object} obj - Object to flatten
+ * @param {string} [prefix=''] - Key prefix for recursion
+ * @param {Object} [result={}] - Result accumulator
+ * @returns {Object} Flattened object with dot-notation keys
+ * @private
+ */
+function flattenObject(obj, prefix = '', result = {}) {
+  for (const key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      const newKey = prefix ? `${prefix}.${key}` : key;
+      const value = obj[key];
+
+      if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+        flattenObject(value, newKey, result);
+      } else {
+        result[newKey] = value;
+      }
+    }
+  }
+  return result;
+}
+
+/**
+ * Formats a value for display.
+ *
+ * @param {*} value - Value to format
+ * @returns {string} Formatted string representation
+ * @private
+ */
+function formatValue(value) {
+  if (typeof value === 'boolean') {
+    return value ? 'true' : 'false';
+  }
+  if (typeof value === 'string') {
+    return value;
+  }
+  return JSON.stringify(value);
+}
+
+/**
+ * Parses a configuration value from string input.
+ *
+ * @param {string} value - String value to parse
+ * @returns {*} Parsed value (boolean, number, object, array, or string)
+ * @private
+ */
+function parseValue(value) {
+  if (value === 'true') {
+    return true;
+  }
+  if (value === 'false') {
+    return false;
+  }
+
+  if (value !== '' && !isNaN(value) && !isNaN(parseFloat(value))) {
+    if (value.includes('.')) {
+      return parseFloat(value);
+    }
+    return parseInt(value, 10);
+  }
+
+  if ((value.startsWith('{') && value.endsWith('}')) ||
+      (value.startsWith('[') && value.endsWith(']'))) {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+
+  return value;
+}
+
+/**
+ * Gets a configuration value by key.
+ *
+ * @param {string} key - Configuration key using dot-notation
+ * @param {Object} options - Command options
+ * @param {boolean} [options.verbose] - Enable verbose output
+ * @returns {Promise<number>} Exit code
+ */
+export async function configGetCommand(key, options = {}) {
+  setVerbose(options.verbose);
+
+  logger.debug('Starting config get command');
+  logger.debug(`Key: ${key}, verbose: ${options.verbose}`);
+
+  try {
+    if (!key || typeof key !== 'string') {
+      logger.error('Configuration key is required');
+      logger.dim('Usage: gsd-opencode config get <key>');
+      return ERROR_CODES.GENERAL_ERROR;
+    }
+
+    const settings = new SettingsManager();
+    const value = await settings.get(key);
+
+    if (value === undefined) {
+      logger.error(`Configuration key not found: ${key}`);
+      return ERROR_CODES.GENERAL_ERROR;
+    }
+
+    if (typeof value === 'object' && value !== null) {
+      console.log(JSON.stringify(value));
+    } else {
+      console.log(String(value));
+    }
+
+    return ERROR_CODES.SUCCESS;
+
+  } catch (error) {
+    if (error.name === 'AbortPromptError' || error.message?.includes('cancel')) {
+      logger.info('\nCommand cancelled by user');
+      return ERROR_CODES.INTERRUPTED;
+    }
+
+    logger.error(`Failed to get configuration: ${error.message}`);
+
+    if (options.verbose) {
+      logger.debug(error.stack);
+    }
+
+    return ERROR_CODES.GENERAL_ERROR;
+  }
+}
+
+/**
+ * Sets a configuration value by key.
+ *
+ * @param {string} key - Configuration key using dot-notation
+ * @param {string} value - Value to set (will be auto-parsed)
+ * @param {Object} options - Command options
+ * @param {boolean} [options.verbose] - Enable verbose output
+ * @returns {Promise<number>} Exit code
+ */
+export async function configSetCommand(key, value, options = {}) {
+  setVerbose(options.verbose);
+
+  logger.debug('Starting config set command');
+  logger.debug(`Key: ${key}, value: ${value}, verbose: ${options.verbose}`);
+
+  try {
+    if (!key || typeof key !== 'string') {
+      logger.error('Configuration key is required');
+      logger.dim('Usage: gsd-opencode config set <key> <value>');
+      return ERROR_CODES.GENERAL_ERROR;
+    }
+
+    if (value === undefined || value === null) {
+      logger.error('Configuration value is required');
+      logger.dim('Usage: gsd-opencode config set <key> <value>');
+      return ERROR_CODES.GENERAL_ERROR;
+    }
+
+    const parsedValue = parseValue(String(value));
+    logger.debug(`Parsed value: ${JSON.stringify(parsedValue)} (type: ${typeof parsedValue})`);
+
+    const settings = new SettingsManager();
+    await settings.set(key, parsedValue);
+
+    logger.success(`Set ${key} = ${JSON.stringify(parsedValue)}`);
+
+    return ERROR_CODES.SUCCESS;
+
+  } catch (error) {
+    if (error.name === 'AbortPromptError' || error.message?.includes('cancel')) {
+      logger.info('\nCommand cancelled by user');
+      return ERROR_CODES.INTERRUPTED;
+    }
+
+    logger.error(`Failed to set configuration: ${error.message}`);
+
+    if (options.verbose) {
+      logger.debug(error.stack);
+    }
+
+    return ERROR_CODES.GENERAL_ERROR;
+  }
+}
+
+/**
+ * Resets configuration to defaults.
+ *
+ * @param {string} [key] - Specific key to reset, or omit to use --all
+ * @param {Object} options - Command options
+ * @param {boolean} [options.all] - Reset all settings to defaults
+ * @param {boolean} [options.verbose] - Enable verbose output
+ * @returns {Promise<number>} Exit code
+ */
+export async function configResetCommand(key, options = {}) {
+  setVerbose(options.verbose);
+
+  logger.debug('Starting config reset command');
+  logger.debug(`Key: ${key}, all: ${options.all}, verbose: ${options.verbose}`);
+
+  try {
+    const settings = new SettingsManager();
+
+    if (options.all) {
+      await settings.reset();
+      logger.success('All configuration reset to defaults');
+      return ERROR_CODES.SUCCESS;
+    }
+
+    if (key && typeof key === 'string') {
+      const currentValue = await settings.get(key);
+      if (currentValue === undefined) {
+        logger.error(`Configuration key not found: ${key}`);
+        return ERROR_CODES.GENERAL_ERROR;
+      }
+
+      await settings.reset(key);
+      logger.success(`Reset ${key} to default`);
+      return ERROR_CODES.SUCCESS;
+    }
+
+    logger.error('Specify a configuration key or use --all to reset all settings');
+    logger.dim('Usage: gsd-opencode config reset <key>');
+    logger.dim('   or: gsd-opencode config reset --all');
+    return ERROR_CODES.GENERAL_ERROR;
+
+  } catch (error) {
+    if (error.name === 'AbortPromptError' || error.message?.includes('cancel')) {
+      logger.info('\nCommand cancelled by user');
+      return ERROR_CODES.INTERRUPTED;
+    }
+
+    logger.error(`Failed to reset configuration: ${error.message}`);
+
+    if (options.verbose) {
+      logger.debug(error.stack);
+    }
+
+    return ERROR_CODES.GENERAL_ERROR;
+  }
+}
+
+/**
+ * Lists all configuration settings.
+ *
+ * @param {Object} options - Command options
+ * @param {boolean} [options.json] - Output as JSON
+ * @param {boolean} [options.verbose] - Enable verbose output
+ * @returns {Promise<number>} Exit code
+ */
+export async function configListCommand(options = {}) {
+  setVerbose(options.verbose);
+
+  logger.debug('Starting config list command');
+  logger.debug(`json: ${options.json}, verbose: ${options.verbose}`);
+
+  try {
+    const settings = new SettingsManager();
+    const config = await settings.list();
+
+    if (options.json) {
+      console.log(JSON.stringify(config, null, 2));
+    } else {
+      logger.heading('Configuration');
+      logger.dim(`Source: ${settings.getConfigPath()}`);
+      logger.dim('');
+
+      const flatConfig = flattenObject(config);
+
+      if (Object.keys(flatConfig).length === 0) {
+        logger.dim('No configuration settings');
+      } else {
+        const keys = Object.keys(flatConfig);
+        const maxKeyLength = Math.max(...keys.map(k => k.length));
+
+        for (const key of keys.sort()) {
+          const value = flatConfig[key];
+          const paddedKey = key.padEnd(maxKeyLength);
+          const formattedValue = formatValue(value);
+          logger.dim(`  ${paddedKey}  ${formattedValue}`);
+        }
+      }
+    }
+
+    return ERROR_CODES.SUCCESS;
+
+  } catch (error) {
+    if (error.name === 'AbortPromptError' || error.message?.includes('cancel')) {
+      logger.info('\nCommand cancelled by user');
+      return ERROR_CODES.INTERRUPTED;
+    }
+
+    logger.error(`Failed to list configuration: ${error.message}`);
+
+    if (options.verbose) {
+      logger.debug(error.stack);
+    }
+
+    return ERROR_CODES.GENERAL_ERROR;
+  }
+}
+
+/**
+ * Default export for the config commands.
+ */
+export default {
+  configGetCommand,
+  configSetCommand,
+  configResetCommand,
+  configListCommand
+};