scene-capability-engine 3.0.0

package/lib/commands/workflows.js

@@ -0,0 +1,240 @@
+/**
+ * Workflows Command
+ * 
+ * Lists and displays manual workflow documentation
+ */
+
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Available workflows
+ */
+const WORKFLOWS = {
+  'task-sync': {
+    name: 'Task Sync Workflow',
+    description: 'Keep workspace synchronized with task progress',
+    timeEstimate: '30-60 seconds',
+    file: 'manual-workflows-guide.md',
+    section: 'task-sync-workflow'
+  },
+  'context-export': {
+    name: 'Context Export Workflow',
+    description: 'Export spec context for sharing',
+    timeEstimate: '15-45 seconds',
+    file: 'manual-workflows-guide.md',
+    section: 'context-export-workflow'
+  },
+  'prompt-generation': {
+    name: 'Prompt Generation Workflow',
+    description: 'Generate AI prompts for specific tasks',
+    timeEstimate: '20-30 seconds',
+    file: 'manual-workflows-guide.md',
+    section: 'prompt-generation-workflow'
+  },
+  'daily': {
+    name: 'Daily Workflow Checklist',
+    description: 'Complete daily workflow checklist',
+    timeEstimate: '2-3 minutes',
+    file: 'manual-workflows-guide.md',
+    section: 'daily-workflow-checklist'
+  },
+  'task-completion': {
+    name: 'Task Completion Checklist',
+    description: 'Checklist for completing a task',
+    timeEstimate: 'Varies',
+    file: 'manual-workflows-guide.md',
+    section: 'task-completion-checklist'
+  },
+  'spec-creation': {
+    name: 'Spec Creation Checklist',
+    description: 'Checklist for creating a new spec',
+    timeEstimate: '10-15 minutes',
+    file: 'manual-workflows-guide.md',
+    section: 'spec-creation-checklist'
+  }
+};
+
+/**
+ * List all available workflows
+ */
+async function listWorkflows() {
+  console.log(chalk.blue('📋 Available Workflows'));
+  console.log();
+  
+  Object.entries(WORKFLOWS).forEach(([id, workflow]) => {
+    console.log(chalk.cyan(`  ${id}`));
+    console.log(`    ${workflow.name}`);
+    console.log(chalk.gray(`    ${workflow.description}`));
+    console.log(chalk.gray(`    Time: ${workflow.timeEstimate}`));
+    console.log();
+  });
+  
+  console.log(chalk.gray('Run'), chalk.cyan('kse workflows show <workflow-id>'), chalk.gray('to view details'));
+  console.log(chalk.gray('Run'), chalk.cyan('kse workflows guide'), chalk.gray('to open full guide'));
+}
+
+/**
+ * Show specific workflow details
+ * 
+ * @param {string} workflowId - Workflow ID
+ */
+async function showWorkflow(workflowId) {
+  const workflow = WORKFLOWS[workflowId];
+  
+  if (!workflow) {
+    console.log(chalk.red('❌ Unknown workflow:'), workflowId);
+    console.log();
+    console.log(chalk.gray('Available workflows:'));
+    Object.keys(WORKFLOWS).forEach(id => {
+      console.log(chalk.gray(`  - ${id}`));
+    });
+    return;
+  }
+  
+  console.log(chalk.blue('📋'), chalk.bold(workflow.name));
+  console.log();
+  console.log(chalk.gray('Description:'), workflow.description);
+  console.log(chalk.gray('Time Estimate:'), workflow.timeEstimate);
+  console.log();
+  
+  // Try to read and display the workflow section
+  try {
+    const docsPath = path.join(__dirname, '../../docs', workflow.file);
+    
+    if (await fs.pathExists(docsPath)) {
+      console.log(chalk.blue('📖 Full documentation:'));
+      console.log(chalk.cyan(`  docs/${workflow.file}#${workflow.section}`));
+      console.log();
+      console.log(chalk.gray('Tip: Open the file in your editor for complete instructions'));
+    } else {
+      console.log(chalk.yellow('⚠️  Documentation file not found'));
+      console.log(chalk.gray(`  Expected: docs/${workflow.file}`));
+    }
+  } catch (error) {
+    console.log(chalk.yellow('⚠️  Could not read documentation'));
+  }
+}
+
+/**
+ * Open full workflows guide
+ */
+async function openGuide() {
+  const guidePath = path.join(__dirname, '../../docs/manual-workflows-guide.md');
+  
+  try {
+    if (await fs.pathExists(guidePath)) {
+      console.log(chalk.blue('📖 Manual Workflows Guide'));
+      console.log();
+      console.log(chalk.cyan('  docs/manual-workflows-guide.md'));
+      console.log();
+      console.log(chalk.gray('Open this file in your editor for complete workflow documentation'));
+      console.log();
+      console.log(chalk.blue('Contents:'));
+      console.log(chalk.gray('  - Task Sync Workflow'));
+      console.log(chalk.gray('  - Context Export Workflow'));
+      console.log(chalk.gray('  - Prompt Generation Workflow'));
+      console.log(chalk.gray('  - Workflow Checklists'));
+      console.log(chalk.gray('  - Time Estimates'));
+      console.log(chalk.gray('  - Troubleshooting'));
+    } else {
+      console.log(chalk.red('❌ Guide not found:'), 'docs/manual-workflows-guide.md');
+    }
+  } catch (error) {
+    console.log(chalk.red('❌ Error:'), error.message);
+  }
+}
+
+/**
+ * Track workflow completion
+ * 
+ * @param {string} workflowId - Workflow ID
+ */
+async function trackCompletion(workflowId) {
+  const workflow = WORKFLOWS[workflowId];
+  
+  if (!workflow) {
+    console.log(chalk.red('❌ Unknown workflow:'), workflowId);
+    return;
+  }
+  
+  console.log(chalk.green('✅'), chalk.bold(`${workflow.name} completed!`));
+  console.log();
+  console.log(chalk.gray('Time estimate:'), workflow.timeEstimate);
+  console.log();
+  console.log(chalk.blue('💡 Next steps:'));
+  
+  // Suggest next workflow based on current one
+  const suggestions = {
+    'task-sync': ['context-export', 'prompt-generation'],
+    'context-export': ['prompt-generation', 'task-completion'],
+    'prompt-generation': ['task-completion'],
+    'daily': ['task-sync', 'context-export'],
+    'task-completion': ['task-sync'],
+    'spec-creation': ['task-sync', 'prompt-generation']
+  };
+  
+  const nextWorkflows = suggestions[workflowId] || [];
+  
+  if (nextWorkflows.length > 0) {
+    nextWorkflows.forEach(nextId => {
+      const next = WORKFLOWS[nextId];
+      console.log(chalk.cyan(`  kse workflows show ${nextId}`), chalk.gray(`- ${next.name}`));
+    });
+  } else {
+    console.log(chalk.gray('  Continue with your work!'));
+  }
+}
+
+/**
+ * Main workflows command
+ * 
+ * @param {string} action - Action to perform (list, show, guide, complete)
+ * @param {string} workflowId - Workflow ID (for show/complete actions)
+ */
+async function workflowsCommand(action = 'list', workflowId = null) {
+  try {
+    switch (action) {
+      case 'list':
+        await listWorkflows();
+        break;
+      
+      case 'show':
+        if (!workflowId) {
+          console.log(chalk.red('❌ Workflow ID required'));
+          console.log(chalk.gray('Usage:'), chalk.cyan('kse workflows show <workflow-id>'));
+          return;
+        }
+        await showWorkflow(workflowId);
+        break;
+      
+      case 'guide':
+        await openGuide();
+        break;
+      
+      case 'complete':
+        if (!workflowId) {
+          console.log(chalk.red('❌ Workflow ID required'));
+          console.log(chalk.gray('Usage:'), chalk.cyan('kse workflows complete <workflow-id>'));
+          return;
+        }
+        await trackCompletion(workflowId);
+        break;
+      
+      default:
+        console.log(chalk.red('❌ Unknown action:'), action);
+        console.log();
+        console.log(chalk.gray('Available actions:'));
+        console.log(chalk.gray('  - list: List all workflows'));
+        console.log(chalk.gray('  - show <id>: Show workflow details'));
+        console.log(chalk.gray('  - guide: Open full guide'));
+        console.log(chalk.gray('  - complete <id>: Mark workflow as complete'));
+    }
+  } catch (error) {
+    console.log(chalk.red('❌ Error:'), error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = workflowsCommand;

package/lib/commands/workspace-multi.js

@@ -0,0 +1,325 @@
+/**
+ * Multi-Workspace Management Commands
+ * 
+ * Implements CLI commands for managing multiple kse project workspaces.
+ * This is part of Spec 16-00: Multi-Workspace Management.
+ * 
+ * Uses WorkspaceStateManager for atomic operations and single source of truth.
+ */
+
+const chalk = require('chalk');
+const path = require('path');
+const WorkspaceStateManager = require('../workspace/multi/workspace-state-manager');
+const fs = require('fs-extra');
+
+/**
+ * Create a new workspace
+ * 
+ * Command: kse workspace create <name> [path]
+ * 
+ * @param {string} name - Workspace name
+ * @param {Object} options - Command options
+ * @param {string} options.path - Optional workspace path (defaults to current directory)
+ * @returns {Promise<void>}
+ */
+async function createWorkspace(name, options = {}) {
+  const stateManager = new WorkspaceStateManager();
+  
+  try {
+    // Use provided path or current directory
+    const workspacePath = options.path || process.cwd();
+    
+    console.log(chalk.red('🔥') + ' Creating Workspace');
+    console.log();
+    console.log(`Name: ${chalk.cyan(name)}`);
+    console.log(`Path: ${chalk.gray(workspacePath)}`);
+    console.log();
+    
+    // Create workspace (atomic operation)
+    const workspace = await stateManager.createWorkspace(name, workspacePath);
+    
+    console.log(chalk.green('✅ Workspace created successfully'));
+    console.log();
+    console.log('Workspace Details:');
+    console.log(`  Name: ${chalk.cyan(workspace.name)}`);
+    console.log(`  Path: ${chalk.gray(workspace.path)}`);
+    console.log(`  Created: ${chalk.gray(workspace.createdAt.toLocaleString())}`);
+    console.log();
+    console.log('Next steps:');
+    console.log(`  ${chalk.cyan('kse workspace switch ' + name)} - Set as active workspace`);
+    console.log(`  ${chalk.cyan('kse workspace list')} - View all workspaces`);
+    
+  } catch (error) {
+    console.log(chalk.red('❌ Error:'), error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * List all registered workspaces
+ * 
+ * Command: kse workspace list
+ * 
+ * @param {Object} options - Command options
+ * @returns {Promise<void>}
+ */
+async function listWorkspaces(options = {}) {
+  const stateManager = new WorkspaceStateManager();
+  
+  try {
+    console.log(chalk.red('🔥') + ' Registered Workspaces');
+    console.log();
+    
+    const workspaces = await stateManager.listWorkspaces();
+    const activeWorkspace = await stateManager.getActiveWorkspace();
+    const activeWorkspaceName = activeWorkspace ? activeWorkspace.name : null;
+    
+    if (workspaces.length === 0) {
+      console.log(chalk.gray('No workspaces registered'));
+      console.log();
+      console.log('Create your first workspace:');
+      console.log(`  ${chalk.cyan('kse workspace create <name>')}`);
+      return;
+    }
+    
+    // Sort by last accessed (most recent first)
+    workspaces.sort((a, b) => b.lastAccessed - a.lastAccessed);
+    
+    console.log(`Found ${chalk.cyan(workspaces.length)} workspace(s):\n`);
+    
+    for (const workspace of workspaces) {
+      const isActive = workspace.name === activeWorkspaceName;
+      const indicator = isActive ? chalk.green('● ') : chalk.gray('○ ');
+      const nameDisplay = isActive ? chalk.green.bold(workspace.name) : chalk.cyan(workspace.name);
+      
+      console.log(`${indicator}${nameDisplay}`);
+      console.log(`  Path: ${chalk.gray(workspace.path)}`);
+      console.log(`  Last accessed: ${chalk.gray(workspace.lastAccessed.toLocaleString())}`);
+      
+      if (isActive) {
+        console.log(`  ${chalk.green('(Active)')}`);
+      }
+      
+      console.log();
+    }
+    
+    console.log('Commands:');
+    console.log(`  ${chalk.cyan('kse workspace switch <name>')} - Switch to a workspace`);
+    console.log(`  ${chalk.cyan('kse workspace info <name>')} - View workspace details`);
+    
+  } catch (error) {
+    console.log(chalk.red('❌ Error:'), error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Switch to a different workspace
+ * 
+ * Command: kse workspace switch <name>
+ * 
+ * @param {string} name - Workspace name
+ * @param {Object} options - Command options
+ * @returns {Promise<void>}
+ */
+async function switchWorkspace(name, options = {}) {
+  const stateManager = new WorkspaceStateManager();
+  
+  try {
+    console.log(chalk.red('🔥') + ' Switching Workspace');
+    console.log();
+    
+    // Switch workspace (atomic operation - updates active + timestamp)
+    await stateManager.switchWorkspace(name);
+    
+    const workspace = await stateManager.getWorkspace(name);
+    
+    console.log(chalk.green('✅ Switched to workspace:'), chalk.cyan(name));
+    console.log();
+    console.log('Workspace Details:');
+    console.log(`  Path: ${chalk.gray(workspace.path)}`);
+    console.log(`  Last accessed: ${chalk.gray(workspace.lastAccessed.toLocaleString())}`);
+    console.log();
+    console.log('All kse commands will now use this workspace by default.');
+    
+  } catch (error) {
+    console.log(chalk.red('❌ Error:'), error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Remove a workspace from the registry
+ * 
+ * Command: kse workspace remove <name>
+ * 
+ * @param {string} name - Workspace name
+ * @param {Object} options - Command options
+ * @param {boolean} options.force - Skip confirmation prompt
+ * @returns {Promise<void>}
+ */
+async function removeWorkspace(name, options = {}) {
+  const stateManager = new WorkspaceStateManager();
+  
+  try {
+    console.log(chalk.red('🔥') + ' Removing Workspace');
+    console.log();
+    
+    // Check if workspace exists
+    const workspace = await stateManager.getWorkspace(name);
+    if (!workspace) {
+      const available = await stateManager.listWorkspaces();
+      const availableNames = available.map(ws => ws.name);
+      
+      console.log(chalk.red('❌ Workspace not found:'), name);
+      console.log();
+      if (availableNames.length > 0) {
+        console.log('Available workspaces:', availableNames.join(', '));
+      } else {
+        console.log('No workspaces registered.');
+      }
+      process.exit(1);
+    }
+    
+    console.log(`Workspace: ${chalk.cyan(name)}`);
+    console.log(`Path: ${chalk.gray(workspace.path)}`);
+    console.log();
+    
+    // Require confirmation unless --force
+    if (!options.force) {
+      console.log(chalk.yellow('⚠️  Warning: This will remove the workspace from the registry.'));
+      console.log(chalk.yellow('   Files in the workspace directory will NOT be deleted.'));
+      console.log();
+      console.log('To confirm, run:');
+      console.log(`  ${chalk.cyan('kse workspace remove ' + name + ' --force')}`);
+      return;
+    }
+    
+    // Check if it's the active workspace
+    const activeWorkspace = await stateManager.getActiveWorkspace();
+    const isActive = activeWorkspace && name === activeWorkspace.name;
+    
+    // Remove workspace (atomic operation - removes + clears active if needed)
+    await stateManager.removeWorkspace(name);
+    
+    console.log(chalk.green('✅ Workspace removed:'), chalk.cyan(name));
+    console.log();
+    console.log('The workspace directory and its files have been preserved.');
+    
+    if (isActive) {
+      console.log();
+      console.log(chalk.yellow('Note: This was your active workspace.'));
+      console.log('Set a new active workspace:');
+      console.log(`  ${chalk.cyan('kse workspace switch <name>')}`);
+    }
+    
+  } catch (error) {
+    console.log(chalk.red('❌ Error:'), error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Display detailed information about a workspace
+ * 
+ * Command: kse workspace info [name]
+ * 
+ * @param {string|null} name - Workspace name (optional, defaults to active workspace)
+ * @param {Object} options - Command options
+ * @returns {Promise<void>}
+ */
+async function infoWorkspace(name = null, options = {}) {
+  const stateManager = new WorkspaceStateManager();
+  
+  try {
+    console.log(chalk.red('🔥') + ' Workspace Information');
+    console.log();
+    
+    let workspace;
+    
+    // If no name provided, use active workspace
+    if (!name) {
+      workspace = await stateManager.getActiveWorkspace();
+      
+      if (!workspace) {
+        console.log(chalk.yellow('⚠️  No active workspace set'));
+        console.log();
+        console.log('Set an active workspace:');
+        console.log(`  ${chalk.cyan('kse workspace switch <name>')}`);
+        console.log();
+        console.log('Or specify a workspace name:');
+        console.log(`  ${chalk.cyan('kse workspace info <name>')}`);
+        return;
+      }
+    } else {
+      workspace = await stateManager.getWorkspace(name);
+      
+      if (!workspace) {
+        const available = await stateManager.listWorkspaces();
+        const availableNames = available.map(ws => ws.name);
+        
+        console.log(chalk.red('❌ Workspace not found:'), name);
+        console.log();
+        if (availableNames.length > 0) {
+          console.log('Available workspaces:', availableNames.join(', '));
+        }
+        process.exit(1);
+      }
+    }
+    
+    // Check if it's the active workspace
+    const activeWorkspace = await stateManager.getActiveWorkspace();
+    const isActive = activeWorkspace && workspace.name === activeWorkspace.name;
+    
+    // Count Specs in workspace
+    let specCount = 0;
+    try {
+      const specsPath = path.join(workspace.getPlatformPath(), '.kiro', 'specs');
+      const exists = await fs.pathExists(specsPath);
+      
+      if (exists) {
+        const entries = await fs.readdir(specsPath);
+        // Count directories (each Spec is a directory)
+        for (const entry of entries) {
+          const entryPath = path.join(specsPath, entry);
+          const stats = await fs.stat(entryPath);
+          if (stats.isDirectory()) {
+            specCount++;
+          }
+        }
+      }
+    } catch (error) {
+      // Ignore errors counting Specs
+    }
+    
+    // Display information
+    console.log(`Name: ${chalk.cyan.bold(workspace.name)}`);
+    if (isActive) {
+      console.log(`Status: ${chalk.green('Active')}`);
+    }
+    console.log();
+    console.log('Details:');
+    console.log(`  Path: ${chalk.gray(workspace.path)}`);
+    console.log(`  Created: ${chalk.gray(workspace.createdAt.toLocaleString())}`);
+    console.log(`  Last accessed: ${chalk.gray(workspace.lastAccessed.toLocaleString())}`);
+    console.log(`  Specs: ${chalk.cyan(specCount)}`);
+    console.log();
+    
+    if (!isActive) {
+      console.log('Switch to this workspace:');
+      console.log(`  ${chalk.cyan('kse workspace switch ' + workspace.name)}`);
+    }
+    
+  } catch (error) {
+    console.log(chalk.red('❌ Error:'), error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  createWorkspace,
+  listWorkspaces,
+  switchWorkspace,
+  removeWorkspace,
+  infoWorkspace
+};