kiro-spec-engine 1.2.3 → 1.4.0

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;

package/lib/commands/task.js

@@ -0,0 +1,199 @@
+/**
+ * Task Command Group
+ * 
+ * Manages task claiming and status updates
+ */
+
+const chalk = require('chalk');
+const TaskClaimer = require('../task/task-claimer');
+const WorkspaceManager = require('../workspace/workspace-manager');
+
+/**
+ * Claim a task
+ * 
+ * @param {string} specName - Spec name
+ * @param {string} taskId - Task ID
+ * @param {Object} options - Command options
+ * @param {string} options.user - Override username
+ * @param {boolean} options.force - Force claim even if already claimed
+ * @returns {Promise<void>}
+ */
+async function claimTask(specName, taskId, options = {}) {
+  const projectPath = process.cwd();
+  const taskClaimer = new TaskClaimer();
+  const workspaceManager = new WorkspaceManager();
+  
+  console.log(chalk.red('🔥') + ' Claiming Task');
+  console.log();
+  
+  try {
+    const username = options.user || await workspaceManager.detectUsername();
+    
+    if (!username) {
+      console.log(chalk.red('❌ Could not detect username'));
+      console.log();
+      console.log('Please configure git or use --user flag');
+      return;
+    }
+    
+    console.log(`Spec: ${chalk.cyan(specName)}`);
+    console.log(`Task: ${chalk.cyan(taskId)}`);
+    console.log(`User: ${chalk.cyan(username)}`);
+    console.log();
+    
+    const result = await taskClaimer.claimTask(
+      projectPath,
+      specName,
+      taskId,
+      username,
+      options.force
+    );
+    
+    if (result.success) {
+      console.log(chalk.green('✅ Task claimed successfully'));
+      console.log();
+      console.log(`Task: ${result.taskTitle}`);
+      console.log(`Claimed by: ${chalk.cyan(username)}`);
+      console.log(`Claimed at: ${chalk.gray(result.claimedAt)}`);
+      
+      if (result.previousClaim) {
+        console.log();
+        console.log(chalk.yellow('⚠️  Previous claim overridden:'));
+        console.log(`  User: ${result.previousClaim.username}`);
+        console.log(`  Time: ${result.previousClaim.timestamp}`);
+      }
+    } else {
+      console.log(chalk.red('❌ Failed to claim task'));
+      console.log();
+      console.log(`Error: ${result.error}`);
+      
+      if (result.existingClaim) {
+        console.log();
+        console.log('Task is already claimed by:');
+        console.log(`  User: ${chalk.cyan(result.existingClaim.username)}`);
+        console.log(`  Time: ${chalk.gray(result.existingClaim.timestamp)}`);
+        console.log();
+        console.log('Use ' + chalk.cyan('--force') + ' to override the claim');
+      }
+    }
+  } catch (error) {
+    console.log(chalk.red('❌ Error:'), error.message);
+  }
+}
+
+/**
+ * Unclaim a task
+ * 
+ * @param {string} specName - Spec name
+ * @param {string} taskId - Task ID
+ * @param {Object} options - Command options
+ * @param {string} options.user - Override username
+ * @returns {Promise<void>}
+ */
+async function unclaimTask(specName, taskId, options = {}) {
+  const projectPath = process.cwd();
+  const taskClaimer = new TaskClaimer();
+  const workspaceManager = new WorkspaceManager();
+  
+  console.log(chalk.red('🔥') + ' Unclaiming Task');
+  console.log();
+  
+  try {
+    const username = options.user || await workspaceManager.detectUsername();
+    
+    if (!username) {
+      console.log(chalk.red('❌ Could not detect username'));
+      return;
+    }
+    
+    console.log(`Spec: ${chalk.cyan(specName)}`);
+    console.log(`Task: ${chalk.cyan(taskId)}`);
+    console.log(`User: ${chalk.cyan(username)}`);
+    console.log();
+    
+    const result = await taskClaimer.unclaimTask(
+      projectPath,
+      specName,
+      taskId,
+      username
+    );
+    
+    if (result.success) {
+      console.log(chalk.green('✅ Task unclaimed successfully'));
+      console.log();
+      console.log(`Task: ${result.taskTitle}`);
+    } else {
+      console.log(chalk.red('❌ Failed to unclaim task'));
+      console.log();
+      console.log(`Error: ${result.error}`);
+    }
+  } catch (error) {
+    console.log(chalk.red('❌ Error:'), error.message);
+  }
+}
+
+/**
+ * List claimed tasks
+ * 
+ * @param {string} specName - Spec name (optional)
+ * @param {Object} options - Command options
+ * @param {string} options.user - Filter by username
+ * @returns {Promise<void>}
+ */
+async function listClaimedTasks(specName, options = {}) {
+  const projectPath = process.cwd();
+  const taskClaimer = new TaskClaimer();
+  
+  console.log(chalk.red('🔥') + ' Claimed Tasks');
+  console.log();
+  
+  try {
+    if (specName) {
+      // List claimed tasks for specific spec
+      const tasks = await taskClaimer.getClaimedTasks(projectPath, specName);
+      
+      if (tasks.length === 0) {
+        console.log(chalk.gray('No claimed tasks found'));
+        return;
+      }
+      
+      console.log(`Spec: ${chalk.cyan(specName)}`);
+      console.log();
+      
+      // Group by user
+      const byUser = {};
+      for (const task of tasks) {
+        if (!byUser[task.claimedBy]) {
+          byUser[task.claimedBy] = [];
+        }
+        byUser[task.claimedBy].push(task);
+      }
+      
+      for (const [user, userTasks] of Object.entries(byUser)) {
+        if (options.user && user !== options.user) {
+          continue;
+        }
+        
+        console.log(chalk.cyan(`${user} (${userTasks.length} task(s))`));
+        for (const task of userTasks) {
+          const staleMarker = task.isStale ? chalk.yellow(' [STALE]') : '';
+          console.log(`  ${chalk.gray('•')} ${task.taskId} ${task.taskTitle}${staleMarker}`);
+          console.log(`    ${chalk.gray(task.claimedAt)}`);
+        }
+        console.log();
+      }
+    } else {
+      console.log(chalk.gray('Please specify a spec name'));
+      console.log();
+      console.log('Usage: ' + chalk.cyan('kse task list <spec-name>'));
+    }
+  } catch (error) {
+    console.log(chalk.red('❌ Error:'), error.message);
+  }
+}
+
+module.exports = {
+  claimTask,
+  unclaimTask,
+  listClaimedTasks
+};