scene-capability-engine 3.0.0

package/lib/commands/doctor.js

@@ -0,0 +1,273 @@
+const chalk = require('chalk');
+const pythonChecker = require('../python-checker');
+const { getI18n } = require('../i18n');
+const DiagnosticEngine = require('../governance/diagnostic-engine');
+const ConfigManager = require('../governance/config-manager');
+const GitignoreIntegration = require('../gitignore/gitignore-integration');
+const path = require('path');
+
+/**
+ * CLI Doctor Command Component
+ * 
+ * Verifies system requirements and provides diagnostics.
+ * Checks Node.js version, Python availability, and document compliance.
+ * 
+ * Requirements: 7.5, 10.2
+ */
+async function doctorCommand(options = {}) {
+  const i18n = getI18n();
+  
+  // Handle --fix-gitignore flag
+  if (options.fixGitignore) {
+    return await fixGitignoreCommand();
+  }
+  
+  console.log(chalk.red('🔥') + ' ' + i18n.t('cli.commands.doctor.title'));
+  console.log();
+  console.log(i18n.t('cli.commands.doctor.checking'));
+  console.log();
+  
+  // Check Node.js version
+  const nodeVersion = process.version;
+  const nodeStatus = chalk.green('✓');
+  console.log(`${nodeStatus} ${i18n.t('cli.commands.doctor.nodejs')}: ${chalk.cyan(nodeVersion)}`);
+  
+  // Check Python availability
+  const pythonStatus = pythonChecker.checkPython();
+  
+  if (pythonStatus.available) {
+    const pythonOk = chalk.green('✓');
+    console.log(`${pythonOk} ${i18n.t('cli.commands.doctor.python')}: ${chalk.cyan(pythonStatus.version)}`);
+  } else {
+    const pythonFail = chalk.red('✗');
+    console.log(`${pythonFail} ${i18n.t('cli.commands.doctor.python')}: ${chalk.yellow(pythonStatus.message)}`);
+    console.log();
+    console.log(chalk.yellow(i18n.t('cli.commands.doctor.python_note')));
+    console.log();
+    console.log(chalk.blue(i18n.t('python.install_header')));
+    console.log(pythonChecker.getInstallInstructions());
+  }
+  
+  console.log();
+  console.log(chalk.blue('─'.repeat(60)));
+  console.log();
+  
+  // Check document compliance
+  await checkDocumentCompliance(options);
+  
+  console.log();
+  console.log(chalk.blue('─'.repeat(60)));
+  console.log();
+  
+  // Summary
+  if (pythonStatus.available) {
+    console.log(chalk.green('✅ ' + i18n.t('cli.commands.doctor.all_good')));
+    console.log(i18n.t('cli.commands.doctor.ready'));
+  } else {
+    console.log(chalk.yellow('⚠️  ' + i18n.t('cli.commands.doctor.python_missing')));
+    console.log(i18n.t('cli.commands.doctor.basic_features'));
+    console.log(i18n.t('cli.commands.doctor.ultrawork_unavailable'));
+  }
+  
+  console.log();
+}
+
+/**
+ * Check document compliance
+ * 
+ * @param {Object} options - Command options
+ * @param {boolean} options.docs - Whether to show detailed diagnostics
+ */
+async function checkDocumentCompliance(options = {}) {
+  try {
+    const projectPath = process.cwd();
+    
+    // Load configuration
+    const configManager = new ConfigManager(projectPath);
+    const config = await configManager.load();
+    
+    // Run diagnostic scan
+    const diagnosticEngine = new DiagnosticEngine(projectPath, config);
+    const report = await diagnosticEngine.scan();
+    
+    // Display results based on options
+    if (options.docs) {
+      // Detailed diagnostics mode
+      displayDetailedDiagnostics(report);
+    } else {
+      // Brief compliance status
+      displayBriefCompliance(report);
+    }
+  } catch (error) {
+    console.log(chalk.yellow('⚠️  Document compliance check failed:'), error.message);
+  }
+}
+
+/**
+ * Display brief document compliance status
+ * 
+ * @param {Object} report - Diagnostic report
+ */
+function displayBriefCompliance(report) {
+  console.log(chalk.bold('Document Compliance:'));
+  
+  if (report.compliant) {
+    console.log(chalk.green('  ✓ All documents follow lifecycle management rules'));
+  } else {
+    const errorCount = report.summary.bySeverity.error || 0;
+    const warningCount = report.summary.bySeverity.warning || 0;
+    
+    if (errorCount > 0) {
+      console.log(chalk.red(`  ✗ ${errorCount} error(s) found`));
+    }
+    if (warningCount > 0) {
+      console.log(chalk.yellow(`  ⚠ ${warningCount} warning(s) found`));
+    }
+    
+    console.log(chalk.cyan(`  → Run 'kse doctor --docs' for detailed diagnostics`));
+  }
+}
+
+/**
+ * Display detailed document diagnostics
+ * 
+ * @param {Object} report - Diagnostic report
+ */
+function displayDetailedDiagnostics(report) {
+  console.log(chalk.bold.cyan('Document Governance Diagnostic:'));
+  console.log();
+  
+  if (report.compliant) {
+    console.log(chalk.green('  ✅ Project is compliant'));
+    console.log('  All documents follow the lifecycle management rules.');
+    return;
+  }
+  
+  console.log(chalk.yellow(`  ⚠️  Found ${report.violations.length} violation(s)`));
+  console.log();
+  
+  // Group violations by type
+  const byType = groupBy(report.violations, 'type');
+  
+  for (const [type, violations] of Object.entries(byType)) {
+    console.log(chalk.blue(`  ${formatType(type)} (${violations.length})`));
+    
+    for (const violation of violations) {
+      const icon = violation.severity === 'error' ? '❌' : '⚠️';
+      const relativePath = path.relative(process.cwd(), violation.path);
+      console.log(`    ${icon} ${chalk.gray(relativePath)}`);
+      console.log(`       ${violation.description}`);
+      console.log(`       ${chalk.cyan('→ ' + violation.recommendation)}`);
+    }
+    
+    console.log();
+  }
+  
+  // Display recommendations
+  if (report.recommendations && report.recommendations.length > 0) {
+    console.log(chalk.blue('  💡 Recommended Actions:'));
+    report.recommendations.forEach(rec => {
+      console.log(`    • ${rec}`);
+    });
+  }
+}
+
+/**
+ * Helper: Group array by property
+ * 
+ * @param {Array} array - Array to group
+ * @param {string} property - Property to group by
+ * @returns {Object} - Grouped object
+ */
+function groupBy(array, property) {
+  return array.reduce((acc, item) => {
+    const key = item[property];
+    if (!acc[key]) acc[key] = [];
+    acc[key].push(item);
+    return acc;
+  }, {});
+}
+
+/**
+ * Helper: Format violation type
+ * 
+ * @param {string} type - Violation type
+ * @returns {string} - Formatted type
+ */
+function formatType(type) {
+  return type.split('_').map(word => 
+    word.charAt(0).toUpperCase() + word.slice(1)
+  ).join(' ');
+}
+
+/**
+ * Fix .gitignore for team collaboration
+ * 
+ * Standalone command to check and fix .gitignore configuration.
+ * Replaces old blanket .kiro/ exclusion with layered strategy.
+ */
+async function fixGitignoreCommand() {
+  console.log(chalk.cyan('🔧 Checking .gitignore configuration...'));
+  console.log();
+  
+  try {
+    const projectPath = process.cwd();
+    const gitignoreIntegration = new GitignoreIntegration();
+    
+    const result = await gitignoreIntegration.runDoctor(projectPath);
+    
+    if (result.success) {
+      if (result.action === 'skipped') {
+        console.log(chalk.green('✅ .gitignore is already configured correctly'));
+        console.log();
+        console.log('Your .gitignore uses the layered strategy for team collaboration.');
+        console.log('No changes needed.');
+      } else {
+        console.log(chalk.green(`✅ .gitignore ${result.action} successfully`));
+        console.log();
+        console.log(result.message);
+        
+        if (result.backupId) {
+          console.log();
+          console.log(chalk.blue('💾 Backup created:'), chalk.gray(result.backupId));
+          console.log(chalk.gray('   You can restore with: kse rollback ' + result.backupId));
+        }
+        
+        if (result.added && result.added.length > 0) {
+          console.log();
+          console.log(chalk.blue('Added rules:'));
+          result.added.forEach(rule => {
+            console.log(chalk.gray('  + ' + rule));
+          });
+        }
+        
+        if (result.removed && result.removed.length > 0) {
+          console.log();
+          console.log(chalk.blue('Removed rules:'));
+          result.removed.forEach(rule => {
+            console.log(chalk.gray('  - ' + rule));
+          });
+        }
+      }
+      
+      console.log();
+      console.log(chalk.cyan('📖 Learn more:'), 'docs/team-collaboration-guide.md');
+    } else {
+      console.log(chalk.red('❌ Failed to fix .gitignore'));
+      console.log();
+      console.log(chalk.yellow(result.message));
+      console.log();
+      console.log(chalk.cyan('💡 Manual fix:'));
+      console.log('   See docs/team-collaboration-guide.md for instructions');
+    }
+  } catch (error) {
+    console.log(chalk.red('❌ Error:'), error.message);
+    console.log();
+    console.log(chalk.cyan('💡 Manual fix:'));
+    console.log('   See docs/team-collaboration-guide.md for instructions');
+  }
+  
+  console.log();
+}
+
+module.exports = doctorCommand;

package/lib/commands/env.js

@@ -0,0 +1,420 @@
+const path = require('path');
+const fs = require('fs-extra');
+const chalk = require('chalk');
+const EnvironmentManager = require('../environment/environment-manager');
+
+/**
+ * Environment CLI
+ * 
+ * Command-line interface for environment management operations.
+ */
+class EnvironmentCLI {
+  /**
+   * Handle env command
+   * @param {Array} args - Command arguments
+   * @returns {Promise<number>} Exit code
+   */
+  static async handleCommand(args) {
+    const subcommand = args[0];
+
+    try {
+      switch (subcommand) {
+        case 'list':
+          return await this.handleList(args.slice(1));
+        case 'switch':
+          return await this.handleSwitch(args.slice(1));
+        case 'info':
+          return await this.handleInfo(args.slice(1));
+        case 'register':
+          return await this.handleRegister(args.slice(1));
+        case 'unregister':
+          return await this.handleUnregister(args.slice(1));
+        case 'rollback':
+          return await this.handleRollback(args.slice(1));
+        case 'verify':
+          return await this.handleVerify(args.slice(1));
+        case 'run':
+          return await this.handleRun(args.slice(1));
+        default:
+          this.displayHelp();
+          return 1;
+      }
+    } catch (error) {
+      this.displayError(error);
+      return 1;
+    }
+  }
+
+  /**
+   * Handle list command
+   * @param {Array} args - Command arguments
+   * @returns {Promise<number>} Exit code
+   */
+  static async handleList(args) {
+    const projectRoot = process.cwd();
+    const manager = new EnvironmentManager(projectRoot);
+
+    const environments = await manager.listEnvironments();
+
+    if (environments.length === 0) {
+      console.log(chalk.yellow('\nNo environments registered.'));
+      console.log(chalk.gray('\nTo register an environment, create a configuration file and run:'));
+      console.log(chalk.gray('  kse env register <config-file>'));
+      console.log();
+      return 0;
+    }
+
+    console.log(chalk.bold('\nRegistered Environments:\n'));
+
+    for (const env of environments) {
+      const prefix = env.isActive ? chalk.green('● ') : chalk.gray('○ ');
+      const name = env.isActive ? chalk.green.bold(env.name) : chalk.white(env.name);
+      const status = env.isActive ? chalk.green(' (active)') : '';
+      
+      console.log(`${prefix}${name}${status}`);
+      console.log(chalk.gray(`  ${env.description}`));
+      console.log(chalk.gray(`  Config files: ${env.configFilesCount}`));
+      if (env.hasVerification) {
+        console.log(chalk.gray(`  Verification: enabled`));
+      }
+      console.log();
+    }
+
+    return 0;
+  }
+
+  /**
+   * Handle switch command
+   * @param {Array} args - Command arguments
+   * @returns {Promise<number>} Exit code
+   */
+  static async handleSwitch(args) {
+    const environmentName = args[0];
+
+    if (!environmentName) {
+      console.log(chalk.red('\nError: Environment name is required'));
+      console.log(chalk.gray('\nUsage: kse env switch <name>'));
+      console.log();
+      return 1;
+    }
+
+    const projectRoot = process.cwd();
+    const manager = new EnvironmentManager(projectRoot);
+
+    console.log(chalk.gray(`\nSwitching to environment: ${environmentName}...`));
+
+    const result = await manager.switchEnvironment(environmentName);
+
+    if (result.success) {
+      console.log(chalk.green('\n✓ Environment switched successfully!'));
+      console.log();
+      console.log(chalk.gray(`  Previous: ${result.previous_environment || 'none'}`));
+      console.log(chalk.gray(`  Current:  ${result.new_environment}`));
+      console.log(chalk.gray(`  Files copied: ${result.files_copied}`));
+      if (result.backup_created) {
+        console.log(chalk.gray(`  Backup created: ${result.backup_location}`));
+      }
+      console.log();
+      return 0;
+    } else {
+      console.log(chalk.red('\n✗ Environment switch failed:'));
+      for (const error of result.errors) {
+        console.log(chalk.red(`  ${error}`));
+      }
+      console.log();
+      return 1;
+    }
+  }
+
+  /**
+   * Handle info command
+   * @param {Array} args - Command arguments
+   * @returns {Promise<number>} Exit code
+   */
+  static async handleInfo(args) {
+    const projectRoot = process.cwd();
+    const manager = new EnvironmentManager(projectRoot);
+
+    try {
+      const env = await manager.getActiveEnvironment();
+
+      console.log(chalk.bold('\nActive Environment:\n'));
+      console.log(chalk.green.bold(`  ${env.name}`));
+      console.log(chalk.gray(`  ${env.description}`));
+      console.log();
+
+      console.log(chalk.bold('Configuration Files:'));
+      for (const mapping of env.config_files) {
+        console.log(chalk.gray(`  ${mapping.source} → ${mapping.target}`));
+      }
+      console.log();
+
+      if (env.verification) {
+        console.log(chalk.bold('Verification:'));
+        console.log(chalk.gray(`  Command: ${env.verification.command}`));
+        console.log(chalk.gray(`  Expected: ${env.verification.expected_output}`));
+        console.log();
+      }
+
+      return 0;
+    } catch (error) {
+      if (error.message.includes('No active environment')) {
+        console.log(chalk.yellow('\nNo active environment.'));
+        console.log(chalk.gray('\nTo activate an environment, run:'));
+        console.log(chalk.gray('  kse env switch <name>'));
+        console.log();
+        return 0;
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Handle register command
+   * @param {Array} args - Command arguments
+   * @returns {Promise<number>} Exit code
+   */
+  static async handleRegister(args) {
+    const configFile = args[0];
+
+    if (!configFile) {
+      console.log(chalk.red('\nError: Configuration file is required'));
+      console.log(chalk.gray('\nUsage: kse env register <config-file>'));
+      console.log();
+      return 1;
+    }
+
+    const projectRoot = process.cwd();
+    const configPath = path.resolve(projectRoot, configFile);
+
+    if (!await fs.pathExists(configPath)) {
+      console.log(chalk.red(`\nError: Configuration file not found: ${configFile}`));
+      console.log();
+      return 1;
+    }
+
+    try {
+      const configContent = await fs.readFile(configPath, 'utf8');
+      const config = JSON.parse(configContent);
+
+      const manager = new EnvironmentManager(projectRoot);
+      const result = await manager.registerEnvironment(config);
+
+      console.log(chalk.green(`\n✓ ${result.message}`));
+      console.log();
+      return 0;
+    } catch (error) {
+      if (error.name === 'SyntaxError') {
+        console.log(chalk.red('\nError: Invalid JSON in configuration file'));
+        console.log(chalk.red(`  ${error.message}`));
+        console.log();
+        return 1;
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Handle unregister command
+   * @param {Array} args - Command arguments
+   * @returns {Promise<number>} Exit code
+   */
+  static async handleUnregister(args) {
+    const environmentName = args[0];
+    const force = args.includes('--force') || args.includes('-f');
+
+    if (!environmentName) {
+      console.log(chalk.red('\nError: Environment name is required'));
+      console.log(chalk.gray('\nUsage: kse env unregister <name> [--force]'));
+      console.log();
+      return 1;
+    }
+
+    if (!force) {
+      console.log(chalk.yellow(`\nAre you sure you want to unregister "${environmentName}"?`));
+      console.log(chalk.gray('This action cannot be undone.'));
+      console.log(chalk.gray('\nUse --force to skip this confirmation.'));
+      console.log();
+      return 1;
+    }
+
+    const projectRoot = process.cwd();
+    const manager = new EnvironmentManager(projectRoot);
+
+    const result = await manager.unregisterEnvironment(environmentName);
+
+    console.log(chalk.green(`\n✓ ${result.message}`));
+    console.log();
+    return 0;
+  }
+
+  /**
+   * Handle rollback command
+   * @param {Array} args - Command arguments
+   * @returns {Promise<number>} Exit code
+   */
+  static async handleRollback(args) {
+    const projectRoot = process.cwd();
+    const manager = new EnvironmentManager(projectRoot);
+
+    console.log(chalk.gray('\nRestoring from backup...'));
+
+    try {
+      const result = await manager.rollbackEnvironment();
+
+      console.log(chalk.green('\n✓ Rollback successful!'));
+      console.log();
+      console.log(chalk.gray(`  Environment: ${result.environment_name}`));
+      console.log(chalk.gray(`  Files restored: ${result.files_restored}`));
+      console.log(chalk.gray(`  Backup timestamp: ${result.backup_timestamp}`));
+      console.log();
+      return 0;
+    } catch (error) {
+      console.log(chalk.red('\n✗ Rollback failed:'));
+      console.log(chalk.red(`  ${error.message}`));
+      console.log();
+      return 1;
+    }
+  }
+
+  /**
+   * Handle verify command
+   * @param {Array} args - Command arguments
+   * @returns {Promise<number>} Exit code
+   */
+  static async handleVerify(args) {
+    const projectRoot = process.cwd();
+    const manager = new EnvironmentManager(projectRoot);
+
+    console.log(chalk.gray('\nVerifying environment configuration...'));
+
+    try {
+      const result = await manager.verifyEnvironment();
+
+      if (result.success) {
+        console.log(chalk.green('\n✓ Environment verification passed!'));
+        console.log();
+        console.log(chalk.gray(`  Environment: ${result.environment_name}`));
+        if (result.command) {
+          console.log(chalk.gray(`  Command: ${result.command}`));
+          console.log(chalk.gray(`  Expected: ${result.expected_output}`));
+          console.log(chalk.gray(`  Actual: ${result.actual_output}`));
+        } else {
+          console.log(chalk.gray('  No verification rules configured'));
+        }
+        console.log();
+        return 0;
+      } else {
+        console.log(chalk.red('\n✗ Environment verification failed!'));
+        console.log();
+        console.log(chalk.gray(`  Environment: ${result.environment_name}`));
+        console.log(chalk.gray(`  Command: ${result.command}`));
+        console.log(chalk.red(`  Expected: ${result.expected_output}`));
+        console.log(chalk.red(`  Actual: ${result.actual_output}`));
+        if (result.error) {
+          console.log(chalk.red(`  Error: ${result.error}`));
+        }
+        console.log();
+        return 1;
+      }
+    } catch (error) {
+      console.log(chalk.red('\n✗ Verification failed:'));
+      console.log(chalk.red(`  ${error.message}`));
+      console.log();
+      return 1;
+    }
+  }
+
+  /**
+   * Handle run command
+   * @param {Array} args - Command arguments
+   * @returns {Promise<number>} Exit code
+   */
+  static async handleRun(args) {
+    const command = args.join(' ');
+
+    if (!command) {
+      console.log(chalk.red('\nError: Command is required'));
+      console.log(chalk.gray('\nUsage: kse env run "<command>"'));
+      console.log();
+      return 1;
+    }
+
+    const projectRoot = process.cwd();
+    const manager = new EnvironmentManager(projectRoot);
+
+    try {
+      const env = await manager.getActiveEnvironment();
+      console.log(chalk.gray(`\nRunning command in environment: ${env.name}`));
+      console.log(chalk.gray(`Command: ${command}\n`));
+
+      const result = await manager.runInEnvironment(command);
+
+      if (result.output) {
+        console.log(result.output);
+      }
+
+      if (result.success) {
+        console.log(chalk.green(`\n✓ Command completed successfully (exit code: ${result.exit_code})`));
+        console.log();
+        return 0;
+      } else {
+        console.log(chalk.red(`\n✗ Command failed (exit code: ${result.exit_code})`));
+        if (result.error) {
+          console.log(chalk.red(`Error: ${result.error}`));
+        }
+        console.log();
+        return 1;
+      }
+    } catch (error) {
+      console.log(chalk.red('\n✗ Command execution failed:'));
+      console.log(chalk.red(`  ${error.message}`));
+      console.log();
+      return 1;
+    }
+  }
+
+  /**
+   * Display help message
+   */
+  static displayHelp() {
+    console.log(chalk.bold('\nEnvironment Management Commands:\n'));
+    console.log(chalk.white('  kse env list') + chalk.gray('                    List all environments'));
+    console.log(chalk.white('  kse env switch <name>') + chalk.gray('          Switch to environment'));
+    console.log(chalk.white('  kse env info') + chalk.gray('                    Show active environment details'));
+    console.log(chalk.white('  kse env register <config-file>') + chalk.gray(' Register new environment'));
+    console.log(chalk.white('  kse env unregister <name>') + chalk.gray('      Remove environment'));
+    console.log(chalk.white('  kse env rollback') + chalk.gray('               Restore from backup'));
+    console.log(chalk.white('  kse env verify') + chalk.gray('                 Verify environment configuration'));
+    console.log(chalk.white('  kse env run "<command>"') + chalk.gray('        Run command in environment'));
+    console.log();
+  }
+
+  /**
+   * Display error message
+   * @param {Error} error - Error object
+   */
+  static displayError(error) {
+    console.log(chalk.red('\n✗ Error:'));
+    console.log(chalk.red(`  ${error.message}`));
+    console.log();
+  }
+
+  /**
+   * Display success message
+   * @param {string} message - Success message
+   * @param {Object} details - Optional details object
+   */
+  static displaySuccess(message, details = {}) {
+    console.log(chalk.green(`\n✓ ${message}`));
+    if (Object.keys(details).length > 0) {
+      console.log();
+      for (const [key, value] of Object.entries(details)) {
+        console.log(chalk.gray(`  ${key}: ${value}`));
+      }
+    }
+    console.log();
+  }
+}
+
+module.exports = EnvironmentCLI;