kiro-spec-engine 1.2.2 → 1.3.0

package/lib/commands/adopt.js

@@ -12,6 +12,9 @@ const DetectionEngine = require('../adoption/detection-engine');
 const { getAdoptionStrategy } = require('../adoption/adoption-strategy');
 const BackupSystem = require('../backup/backup-system');
 const VersionManager = require('../version/version-manager');
+const SteeringManager = require('../steering/steering-manager');
+const AdoptionConfig = require('../steering/adoption-config');
+const { detectTool, generateAutoConfig } = require('../utils/tool-detector');
 
 /**
  * Executes the adopt command
@@ -134,7 +137,54 @@ async function adoptCommand(options = {}) {
     
     console.log();
     
-    // 7. Create backup if needed
+    // 7. Handle steering strategy if conflicts detected
+    let steeringStrategy = null;
+    let steeringBackupId = null;
+    
+    if (detection.steeringDetection && detection.steeringDetection.hasExistingSteering) {
+      console.log(chalk.blue('🎯 Handling steering files...'));
+      const steeringManager = new SteeringManager();
+      
+      // Prompt for strategy
+      steeringStrategy = await steeringManager.promptStrategy(detection.steeringDetection);
+      
+      if (steeringStrategy === 'use-kse') {
+        // Backup existing steering files
+        console.log(chalk.blue('📦 Backing up existing steering files...'));
+        const backupResult = await steeringManager.backupSteering(projectPath);
+        
+        if (backupResult.success) {
+          steeringBackupId = backupResult.backupId;
+          console.log(chalk.green(`✅ Steering backup created: ${steeringBackupId}`));
+          
+          // Install kse steering files
+          console.log(chalk.blue('📝 Installing kse steering files...'));
+          const installResult = await steeringManager.installKseSteering(projectPath);
+          
+          if (installResult.success) {
+            console.log(chalk.green(`✅ Installed ${installResult.filesInstalled} kse steering file(s)`));
+          } else {
+            console.log(chalk.red(`❌ Failed to install kse steering: ${installResult.error}`));
+            console.log(chalk.yellow('Aborting adoption'));
+            return;
+          }
+        } else {
+          console.log(chalk.red(`❌ Failed to backup steering: ${backupResult.error}`));
+          console.log(chalk.yellow('Aborting adoption for safety'));
+          return;
+        }
+      } else if (steeringStrategy === 'use-project') {
+        console.log(chalk.blue('✅ Keeping existing steering files'));
+      }
+      
+      // Save steering strategy to adoption config
+      const adoptionConfig = new AdoptionConfig(projectPath);
+      await adoptionConfig.updateSteeringStrategy(steeringStrategy, steeringBackupId);
+      
+      console.log();
+    }
+    
+    // 8. Create backup if needed
     let backupId = null;
     if (detection.hasKiroDir && (strategy === 'partial' || strategy === 'full')) {
       console.log(chalk.blue('📦 Creating backup...'));
@@ -153,7 +203,7 @@ async function adoptCommand(options = {}) {
     
     console.log();
     
-    // 8. Execute adoption
+    // 9. Execute adoption
     console.log(chalk.blue('🚀 Executing adoption...'));
     const adoptionStrategy = getAdoptionStrategy(strategy);
     const packageJson = require('../../package.json');
@@ -166,11 +216,19 @@ async function adoptCommand(options = {}) {
     
     console.log();
     
-    // 9. Report results
+    // 10. Report results
     if (result.success) {
       console.log(chalk.green('✅ Adoption completed successfully!'));
       console.log();
       
+      if (steeringStrategy) {
+        console.log(chalk.blue('Steering Strategy:'), steeringStrategy);
+        if (steeringBackupId) {
+          console.log(chalk.gray('  Backup:'), steeringBackupId);
+        }
+        console.log();
+      }
+      
       if (result.filesCreated.length > 0) {
         console.log(chalk.blue('Files created:'));
         result.filesCreated.forEach(file => console.log(`  + ${file}`));
@@ -198,6 +256,62 @@ async function adoptCommand(options = {}) {
         console.log(chalk.gray('  Run'), chalk.cyan('kse rollback'), chalk.gray('if you need to undo changes'));
       }
       
+      console.log();
+      
+      // 11. Detect tool and offer automation setup
+      console.log(chalk.blue('🔍 Detecting your development environment...'));
+      try {
+        const toolDetection = await detectTool(projectPath);
+        const autoConfig = await generateAutoConfig(toolDetection, projectPath);
+        
+        console.log();
+        console.log(chalk.blue('Tool Detected:'), chalk.cyan(toolDetection.primaryTool));
+        console.log(chalk.blue('Confidence:'), autoConfig.confidence);
+        
+        if (autoConfig.notes.length > 0) {
+          console.log();
+          autoConfig.notes.forEach(note => console.log(chalk.gray(`  ℹ️  ${note}`)));
+        }
+        
+        // Offer automation setup (unless --auto)
+        if (!auto && autoConfig.suggestedPresets.length > 0) {
+          console.log();
+          const { setupAutomation } = await inquirer.prompt([
+            {
+              type: 'confirm',
+              name: 'setupAutomation',
+              message: 'Would you like to set up automation for this tool?',
+              default: true
+            }
+          ]);
+          
+          if (setupAutomation) {
+            console.log();
+            console.log(chalk.blue('📋 Recommended automation setup:'));
+            console.log();
+            console.log(chalk.gray('Suggested presets:'));
+            autoConfig.suggestedPresets.forEach(preset => {
+              console.log(`  - ${preset}`);
+            });
+            console.log();
+            console.log(chalk.gray('Run these commands to set up:'));
+            autoConfig.suggestedCommands.forEach(cmd => {
+              console.log(chalk.cyan(`  ${cmd}`));
+            });
+          }
+        } else if (autoConfig.suggestedCommands.length > 0) {
+          console.log();
+          console.log(chalk.blue('💡 Automation setup:'));
+          autoConfig.suggestedCommands.forEach(cmd => {
+            console.log(chalk.gray(`  ${cmd}`));
+          });
+        }
+      } catch (toolError) {
+        // Tool detection is optional, don't fail adoption if it errors
+        console.log(chalk.yellow('⚠️  Could not detect development tool'));
+        console.log(chalk.gray('  You can manually set up automation later'));
+      }
+      
       console.log();
       console.log(chalk.blue('💡 Next steps:'));
       console.log('  1. Review the .kiro/ directory structure');

package/lib/commands/context.js

@@ -0,0 +1,99 @@
+/**
+ * Context Command
+ * 
+ * Exports spec context for cross-tool usage
+ */
+
+const chalk = require('chalk');
+const ContextExporter = require('../context/context-exporter');
+
+/**
+ * Export spec context
+ * 
+ * @param {string} specName - Spec name
+ * @param {Object} options - Command options
+ * @param {boolean} options.requirements - Include requirements (default: true)
+ * @param {boolean} options.design - Include design (default: true)
+ * @param {boolean} options.tasks - Include tasks (default: true)
+ * @param {boolean} options.steering - Include steering rules
+ * @param {string} options.steeringFiles - Comma-separated list of steering files
+ * @returns {Promise<void>}
+ */
+async function exportContext(specName, options = {}) {
+  const projectPath = process.cwd();
+  const exporter = new ContextExporter();
+  
+  console.log(chalk.red('🔥') + ' Exporting Context');
+  console.log();
+  
+  try {
+    console.log(`Spec: ${chalk.cyan(specName)}`);
+    console.log();
+    
+    // Parse options
+    const exportOptions = {
+      includeRequirements: options.requirements !== false,
+      includeDesign: options.design !== false,
+      includeTasks: options.tasks !== false,
+      includeSteering: options.steering === true,
+      steeringFiles: options.steeringFiles 
+        ? options.steeringFiles.split(',').map(f => f.trim())
+        : []
+    };
+    
+    console.log('Export options:');
+    console.log(`  Requirements: ${exportOptions.includeRequirements ? chalk.green('✓') : chalk.gray('✗')}`);
+    console.log(`  Design: ${exportOptions.includeDesign ? chalk.green('✓') : chalk.gray('✗')}`);
+    console.log(`  Tasks: ${exportOptions.includeTasks ? chalk.green('✓') : chalk.gray('✗')}`);
+    console.log(`  Steering: ${exportOptions.includeSteering ? chalk.green('✓') : chalk.gray('✗')}`);
+    
+    if (exportOptions.includeSteering && exportOptions.steeringFiles.length > 0) {
+      console.log(`  Steering files: ${chalk.gray(exportOptions.steeringFiles.join(', '))}`);
+    }
+    
+    console.log();
+    console.log('Exporting...');
+    console.log();
+    
+    const result = await exporter.exportContext(
+      projectPath,
+      specName,
+      exportOptions
+    );
+    
+    if (result.success) {
+      console.log(chalk.green('✅ Context exported successfully'));
+      console.log();
+      console.log(`Export file: ${chalk.cyan(result.exportPath)}`);
+      console.log(`Sections: ${chalk.gray(result.sections)}`);
+      console.log(`Size: ${chalk.gray(formatBytes(result.size))}`);
+      console.log();
+      console.log('Usage:');
+      console.log('  1. Copy the exported file to your AI coding assistant');
+      console.log('  2. Reference specific sections when working on tasks');
+      console.log('  3. Update task status in the original tasks.md after completion');
+    } else {
+      console.log(chalk.red('❌ Export failed'));
+      console.log();
+      console.log(`Error: ${result.error}`);
+    }
+  } catch (error) {
+    console.log(chalk.red('❌ Error:'), error.message);
+  }
+}
+
+/**
+ * Format bytes to human-readable string
+ * 
+ * @param {number} bytes - Bytes
+ * @returns {string} Formatted string
+ */
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+module.exports = {
+  exportContext
+};

package/lib/commands/prompt.js

@@ -0,0 +1,105 @@
+/**
+ * Prompt Command
+ * 
+ * Generates task-specific prompts for AI coding assistants
+ */
+
+const chalk = require('chalk');
+const PromptGenerator = require('../context/prompt-generator');
+
+/**
+ * Generate task prompt
+ * 
+ * @param {string} specName - Spec name
+ * @param {string} taskId - Task ID
+ * @param {Object} options - Command options
+ * @param {string} options.tool - Target tool (generic, claude-code, cursor, codex, kiro)
+ * @param {number} options.maxLength - Maximum context length
+ * @returns {Promise<void>}
+ */
+async function generatePrompt(specName, taskId, options = {}) {
+  const projectPath = process.cwd();
+  const generator = new PromptGenerator();
+  
+  console.log(chalk.red('🔥') + ' Generating Task Prompt');
+  console.log();
+  
+  try {
+    console.log(`Spec: ${chalk.cyan(specName)}`);
+    console.log(`Task: ${chalk.cyan(taskId)}`);
+    
+    const targetTool = options.tool || 'generic';
+    console.log(`Target Tool: ${chalk.cyan(targetTool)}`);
+    console.log();
+    
+    const generateOptions = {
+      targetTool,
+      maxContextLength: options.maxLength || 10000
+    };
+    
+    console.log('Generating prompt...');
+    console.log();
+    
+    const result = await generator.generatePrompt(
+      projectPath,
+      specName,
+      taskId,
+      generateOptions
+    );
+    
+    if (result.success) {
+      console.log(chalk.green('✅ Prompt generated successfully'));
+      console.log();
+      console.log(`Prompt file: ${chalk.cyan(result.promptPath)}`);
+      console.log(`Size: ${chalk.gray(formatBytes(result.size))}`);
+      console.log();
+      console.log('Usage:');
+      console.log('  1. Copy the prompt file content');
+      console.log('  2. Paste it into your AI coding assistant');
+      console.log('  3. Follow the implementation guidelines');
+      console.log('  4. Update task status after completion');
+      console.log();
+      
+      // Tool-specific tips
+      if (targetTool === 'claude-code') {
+        console.log(chalk.blue('💡 Claude Code Tips:'));
+        console.log('  • Copy the entire prompt into the chat');
+        console.log('  • Reference specific sections as needed');
+      } else if (targetTool === 'cursor') {
+        console.log(chalk.blue('💡 Cursor Tips:'));
+        console.log('  • Paste the prompt into the composer');
+        console.log('  • Use Cmd+K to apply changes');
+      } else if (targetTool === 'codex') {
+        console.log(chalk.blue('💡 GitHub Copilot Tips:'));
+        console.log('  • Include the prompt in code comments');
+        console.log('  • Let Copilot suggest implementations');
+      } else if (targetTool === 'kiro') {
+        console.log(chalk.blue('💡 Kiro IDE Tips:'));
+        console.log('  • Steering rules are loaded automatically');
+        console.log('  • Use #File to reference specific files');
+      }
+    } else {
+      console.log(chalk.red('❌ Prompt generation failed'));
+      console.log();
+      console.log(`Error: ${result.error}`);
+    }
+  } catch (error) {
+    console.log(chalk.red('❌ Error:'), error.message);
+  }
+}
+
+/**
+ * Format bytes to human-readable string
+ * 
+ * @param {number} bytes - Bytes
+ * @returns {string} Formatted string
+ */
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+module.exports = {
+  generatePrompt
+};

package/lib/commands/status.js

@@ -0,0 +1,225 @@
+/**
+ * Status Command
+ * 
+ * Displays project status including specs, tasks, and team activity
+ */
+
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs-extra');
+const TaskClaimer = require('../task/task-claimer');
+const WorkspaceManager = require('../workspace/workspace-manager');
+
+/**
+ * Executes the status command
+ * 
+ * @param {Object} options - Command options
+ * @param {boolean} options.verbose - Show detailed information
+ * @param {boolean} options.team - Show team activity
+ * @returns {Promise<void>}
+ */
+async function statusCommand(options = {}) {
+  const { verbose = false, team = false } = options;
+  const projectPath = process.cwd();
+  
+  console.log(chalk.red('🔥') + ' Kiro Spec Engine - Project Status');
+  console.log();
+  
+  try {
+    // 1. Check if .kiro/ exists
+    const kiroPath = path.join(projectPath, '.kiro');
+    const kiroExists = await fs.pathExists(kiroPath);
+    
+    if (!kiroExists) {
+      console.log(chalk.yellow('⚠️  No .kiro/ directory found'));
+      console.log();
+      console.log('This project has not been adopted yet.');
+      console.log('Run ' + chalk.cyan('kse adopt') + ' to get started.');
+      return;
+    }
+    
+    // 2. Check multi-user mode
+    const workspaceManager = new WorkspaceManager();
+    const isMultiUser = await workspaceManager.isMultiUserMode(projectPath);
+    
+    console.log(chalk.blue('📊 Project Information'));
+    console.log(`  Mode: ${isMultiUser ? chalk.cyan('Multi-User') : chalk.gray('Single-User')}`);
+    
+    if (isMultiUser) {
+      const workspaces = await workspaceManager.listWorkspaces(projectPath);
+      console.log(`  Active Users: ${chalk.cyan(workspaces.length)}`);
+      if (verbose) {
+        workspaces.forEach(username => {
+          console.log(`    • ${username}`);
+        });
+      }
+    }
+    
+    console.log();
+    
+    // 3. List specs
+    const specsPath = path.join(projectPath, '.kiro/specs');
+    const specsExist = await fs.pathExists(specsPath);
+    
+    if (!specsExist) {
+      console.log(chalk.yellow('📁 No specs found'));
+      console.log();
+      console.log('Create your first spec: ' + chalk.cyan('kse create-spec my-feature'));
+      return;
+    }
+    
+    const entries = await fs.readdir(specsPath, { withFileTypes: true });
+    const specDirs = entries.filter(entry => 
+      entry.isDirectory() && !entry.name.startsWith('.')
+    );
+    
+    if (specDirs.length === 0) {
+      console.log(chalk.yellow('📁 No specs found'));
+      console.log();
+      console.log('Create your first spec: ' + chalk.cyan('kse create-spec my-feature'));
+      return;
+    }
+    
+    console.log(chalk.blue(`📁 Specs (${specDirs.length})`));
+    console.log();
+    
+    // 4. Analyze each spec
+    const taskClaimer = new TaskClaimer();
+    const allClaimedTasks = [];
+    
+    for (const specDir of specDirs) {
+      const specName = specDir.name;
+      const specPath = path.join(specsPath, specName);
+      
+      // Check for tasks.md
+      const tasksPath = path.join(specPath, 'tasks.md');
+      const tasksExist = await fs.pathExists(tasksPath);
+      
+      if (!tasksExist) {
+        console.log(chalk.gray(`  ${specName}`));
+        console.log(chalk.gray('    No tasks.md found'));
+        console.log();
+        continue;
+      }
+      
+      // Parse tasks
+      const tasks = await taskClaimer.parseTasks(tasksPath);
+      const totalTasks = tasks.length;
+      const completedTasks = tasks.filter(t => t.status === 'completed').length;
+      const inProgressTasks = tasks.filter(t => t.status === 'in-progress').length;
+      const claimedTasks = tasks.filter(t => t.claimedBy);
+      
+      // Calculate completion percentage
+      const completionPercent = totalTasks > 0 
+        ? Math.round((completedTasks / totalTasks) * 100) 
+        : 0;
+      
+      // Display spec info
+      console.log(chalk.cyan(`  ${specName}`));
+      console.log(`    Tasks: ${chalk.green(completedTasks)}/${totalTasks} completed (${completionPercent}%)`);
+      
+      if (inProgressTasks > 0) {
+        console.log(`    In Progress: ${chalk.yellow(inProgressTasks)}`);
+      }
+      
+      if (claimedTasks.length > 0) {
+        console.log(`    Claimed: ${chalk.blue(claimedTasks.length)}`);
+        
+        if (verbose || team) {
+          claimedTasks.forEach(task => {
+            const staleMarker = task.isStale ? chalk.red(' [STALE]') : '';
+            console.log(`      • ${task.taskId} ${task.title}`);
+            console.log(`        ${chalk.gray(`@${task.claimedBy}, ${new Date(task.claimedAt).toLocaleDateString()}`)}${staleMarker}`);
+          });
+        }
+        
+        // Collect for team view
+        claimedTasks.forEach(task => {
+          allClaimedTasks.push({
+            ...task,
+            specName
+          });
+        });
+      }
+      
+      console.log();
+    }
+    
+    // 5. Team activity view
+    if (team && allClaimedTasks.length > 0) {
+      console.log(chalk.blue('👥 Team Activity'));
+      console.log();
+      
+      // Group by user
+      const tasksByUser = {};
+      allClaimedTasks.forEach(task => {
+        if (!tasksByUser[task.claimedBy]) {
+          tasksByUser[task.claimedBy] = [];
+        }
+        tasksByUser[task.claimedBy].push(task);
+      });
+      
+      // Display by user
+      Object.keys(tasksByUser).sort().forEach(username => {
+        const userTasks = tasksByUser[username];
+        const staleTasks = userTasks.filter(t => t.isStale);
+        
+        console.log(chalk.cyan(`  ${username}`));
+        console.log(`    Active Tasks: ${userTasks.length}`);
+        
+        if (staleTasks.length > 0) {
+          console.log(`    ${chalk.red(`Stale Claims: ${staleTasks.length}`)}`);
+        }
+        
+        if (verbose) {
+          userTasks.forEach(task => {
+            const staleMarker = task.isStale ? chalk.red(' [STALE]') : '';
+            const statusColor = task.status === 'completed' ? chalk.green : 
+                               task.status === 'in-progress' ? chalk.yellow : 
+                               chalk.gray;
+            console.log(`      • [${task.specName}] ${task.taskId} ${task.title}`);
+            console.log(`        ${statusColor(task.status)} • ${chalk.gray(new Date(task.claimedAt).toLocaleDateString())}${staleMarker}`);
+          });
+        }
+        
+        console.log();
+      });
+    }
+    
+    // 6. Summary
+    if (allClaimedTasks.length > 0) {
+      const staleClaims = allClaimedTasks.filter(t => t.isStale);
+      
+      if (staleClaims.length > 0) {
+        console.log(chalk.yellow('⚠️  Warning'));
+        console.log(`  ${staleClaims.length} task(s) have stale claims (>7 days old)`);
+        console.log();
+        
+        if (!verbose && !team) {
+          console.log(chalk.gray('  Run with --team or --verbose to see details'));
+          console.log();
+        }
+      }
+    }
+    
+    // 7. Next steps
+    console.log(chalk.blue('💡 Commands'));
+    console.log('  View team activity: ' + chalk.cyan('kse status --team'));
+    console.log('  Detailed view: ' + chalk.cyan('kse status --verbose'));
+    
+    if (isMultiUser) {
+      console.log('  Claim a task: ' + chalk.cyan('kse task claim <spec-name> <task-id>'));
+      console.log('  Sync workspace: ' + chalk.cyan('kse workspace sync'));
+    }
+    
+  } catch (error) {
+    console.log();
+    console.log(chalk.red('❌ Error:'), error.message);
+    console.log();
+    console.log(chalk.gray('If you need help, please report this issue:'));
+    console.log(chalk.cyan('https://github.com/heguangyong/kiro-spec-engine/issues'));
+    process.exit(1);
+  }
+}
+
+module.exports = statusCommand;