universal-dev-standards 4.2.0 → 5.0.0-beta.10

package/src/commands/update.js

@@ -440,15 +440,16 @@ export async function updateCommand(options) {
   // Check for new features (Skills/Commands) not yet installed or outdated
   if (!options.standardsOnly) {
     const latestSkillsVersion = repoInfo.skills.version;
-    const { missingSkills, outdatedSkills, missingCommands } = checkNewFeatures(projectPath, manifest, latestSkillsVersion, options.debug);
+    const { missingSkills, outdatedSkills, missingCommands, outdatedCommands } = checkNewFeatures(projectPath, manifest, latestSkillsVersion, options.debug);
 
-    if (missingSkills.length > 0 || outdatedSkills.length > 0 || missingCommands.length > 0) {
+    if (missingSkills.length > 0 || outdatedSkills.length > 0 || missingCommands.length > 0 || outdatedCommands.length > 0) {
       if (!options.yes) {
         // Interactive mode: prompt user to install/update
-        const { installSkills, updateSkills, installCommands, declinedSkills, declinedCommands } = await promptNewFeatureInstallation(
+        const { installSkills, updateSkills, installCommands, updateCommands, declinedSkills, declinedCommands } = await promptNewFeatureInstallation(
           missingSkills,
           outdatedSkills,
-          missingCommands
+          missingCommands,
+          outdatedCommands
         );
 
         // Install Skills if user agreed
@@ -512,6 +513,7 @@ export async function updateCommand(options) {
           // Update manifest
           if (!manifest.commands) manifest.commands = {};
           manifest.commands.installed = true;
+          manifest.commands.version = repoInfo.skills.version;  // Track version
           manifest.commands.installations = [
             ...(manifest.commands.installations || []),
             ...installCommands
@@ -532,6 +534,30 @@ export async function updateCommand(options) {
           }
         }
 
+        // Update outdated Commands if user agreed
+        if (updateCommands.length > 0) {
+          const updateCmdSpinner = ora(msg.updatingCommands || 'Updating Commands...').start();
+          const updateCmdResult = await installCommandsToMultipleAgents(updateCommands, null, projectPath);
+
+          // Update manifest version
+          if (!manifest.commands) manifest.commands = {};
+          manifest.commands.version = repoInfo.skills.version;
+
+          // Update command hashes for integrity tracking
+          if (updateCmdResult.allFileHashes) {
+            if (!manifest.commandHashes) manifest.commandHashes = {};
+            Object.assign(manifest.commandHashes, updateCmdResult.allFileHashes);
+          }
+
+          if (updateCmdResult.totalErrors === 0) {
+            updateCmdSpinner.succeed((msg.commandsUpdated || 'Updated Commands for {count} AI tools')
+              .replace('{count}', updateCommands.length));
+          } else {
+            updateCmdSpinner.warn((msg.commandsUpdatedWithErrors || 'Updated Commands with {errors} errors')
+              .replace('{errors}', updateCmdResult.totalErrors));
+          }
+        }
+
         // Update declined features in manifest
         if (declinedSkills.length > 0 || declinedCommands.length > 0) {
           if (!manifest.declinedFeatures) manifest.declinedFeatures = {};
@@ -563,7 +589,8 @@ export async function updateCommand(options) {
 
         // Write updated manifest if anything was installed, updated, or declined
         const hasChanges = installSkills.length > 0 || updateSkills.length > 0 ||
-          installCommands.length > 0 || declinedSkills.length > 0 || declinedCommands.length > 0;
+          installCommands.length > 0 || updateCommands.length > 0 ||
+          declinedSkills.length > 0 || declinedCommands.length > 0;
         if (hasChanges) {
           writeManifest(manifest, projectPath);
         }
@@ -583,6 +610,10 @@ export async function updateCommand(options) {
           const toolNames = missingCommands.map(c => c.displayName).join(', ');
           console.log(chalk.gray(`  • Commands (${toolNames}): run "uds update --commands" or "uds init" to install`));
         }
+        if (outdatedCommands.length > 0) {
+          const toolNames = outdatedCommands.map(c => `${c.displayName} (${c.currentVersion} → ${c.latestVersion})`).join(', ');
+          console.log(chalk.gray(`  • Commands update (${toolNames}): run "uds update" interactively to update`));
+        }
       }
     }
   }
@@ -1065,7 +1096,7 @@ async function updateCommandsOnly(projectPath, manifest) {
   );
 
   // Build location summary
-  const locations = commandsInstallations.map(inst => {
+  const locations = (commandsInstallations || []).map(inst => {
     const agent = typeof inst === 'string' ? inst : inst.agent;
     const level = typeof inst === 'string' ? 'project' : (inst.level || 'project');
     const displayName = getAgentDisplayName(agent);
@@ -1083,10 +1114,12 @@ async function updateCommandsOnly(projectPath, manifest) {
   }
 
   // Update manifest
+  const repoInfo = getRepositoryInfo();
   manifest.commands = manifest.commands || {};
   manifest.commands.installed = true;
+  manifest.commands.version = repoInfo.skills.version;  // Track version
   // Normalize to {agent, level} format
-  manifest.commands.installations = commandsInstallations.map(inst => {
+  manifest.commands.installations = (commandsInstallations || []).map(inst => {
     if (typeof inst === 'string') {
       return { agent: inst, level: 'project' };
     }
@@ -1111,7 +1144,7 @@ async function updateCommandsOnly(projectPath, manifest) {
  * @param {Object} manifest - Manifest object
  * @param {string} latestSkillsVersion - Latest skills version from repository
  * @param {boolean} debug - Show debug output
- * @returns {{missingSkills: Array, outdatedSkills: Array, missingCommands: Array}}
+ * @returns {{missingSkills: Array, outdatedSkills: Array, missingCommands: Array, outdatedCommands: Array}}
  */
 function checkNewFeatures(projectPath, manifest, latestSkillsVersion, debug = false) {
   const aiTools = manifest.aiTools || [];
@@ -1132,7 +1165,7 @@ function checkNewFeatures(projectPath, manifest, latestSkillsVersion, debug = fa
     if (debug) {
       console.log(chalk.yellow('  No aiTools in manifest, skipping detection'));
     }
-    return { missingSkills: [], outdatedSkills: [], missingCommands: [] };
+    return { missingSkills: [], outdatedSkills: [], missingCommands: [], outdatedCommands: [] };
   }
 
   // Get declined features from manifest (to exclude from prompts)
@@ -1142,6 +1175,7 @@ function checkNewFeatures(projectPath, manifest, latestSkillsVersion, debug = fa
   const missingSkills = [];
   const outdatedSkills = [];
   const missingCommands = [];
+  const outdatedCommands = [];
 
   for (const tool of aiTools) {
     if (debug) {
@@ -1258,10 +1292,34 @@ function checkNewFeatures(projectPath, manifest, latestSkillsVersion, debug = fa
           displayName: getAgentDisplayName(tool),
           paths: config.commands
         });
-      } else if (debug) {
-        if (hasCommands) {
-          console.log(chalk.gray('    - Commands already installed'));
+      } else if (hasCommands && latestSkillsVersion) {
+        // Check if installed Commands are outdated (similar to Skills)
+        const installedCmdInfo = userCmdInfo?.installed ? userCmdInfo : projectCmdInfo;
+        const installedCmdVersion = installedCmdInfo?.version;
+
+        if (debug) {
+          console.log(chalk.gray(`      installedCmdVersion: ${installedCmdVersion || 'unknown'}`));
+          console.log(chalk.gray(`      latestSkillsVersion: ${latestSkillsVersion}`));
         }
+
+        // Check if version differs from latest
+        if (installedCmdVersion && installedCmdVersion !== latestSkillsVersion) {
+          if (debug) {
+            console.log(chalk.yellow(`    ✓ Added to outdatedCommands (${installedCmdVersion} → ${latestSkillsVersion})`));
+          }
+          outdatedCommands.push({
+            agent: tool,
+            displayName: getAgentDisplayName(tool),
+            paths: config.commands,
+            currentVersion: installedCmdVersion,
+            latestVersion: latestSkillsVersion,
+            level: userCmdInfo?.installed ? 'user' : 'project',
+            path: installedCmdInfo?.path
+          });
+        } else if (debug) {
+          console.log(chalk.gray('    - Commands up to date'));
+        }
+      } else if (debug) {
         if (declinedCommands.includes(tool)) {
           console.log(chalk.gray('    - Previously declined by user'));
         }
@@ -1277,12 +1335,12 @@ function checkNewFeatures(projectPath, manifest, latestSkillsVersion, debug = fa
 
   if (debug) {
     console.log(chalk.cyan('━'.repeat(50)));
-    console.log(chalk.cyan(`Result: ${missingSkills.length} missing Skills, ${outdatedSkills.length} outdated Skills, ${missingCommands.length} missing Commands`));
+    console.log(chalk.cyan(`Result: ${missingSkills.length} missing Skills, ${outdatedSkills.length} outdated Skills, ${missingCommands.length} missing Commands, ${outdatedCommands.length} outdated Commands`));
     console.log(chalk.cyan('━'.repeat(50)));
     console.log();
   }
 
-  return { missingSkills, outdatedSkills, missingCommands };
+  return { missingSkills, outdatedSkills, missingCommands, outdatedCommands };
 }
 
 /**
@@ -1290,14 +1348,15 @@ function checkNewFeatures(projectPath, manifest, latestSkillsVersion, debug = fa
  * @param {Array} missingSkills - Array of {agent, displayName, paths}
  * @param {Array} outdatedSkills - Array of {agent, displayName, paths, currentVersion, latestVersion, level, path}
  * @param {Array} missingCommands - Array of {agent, displayName, path}
- * @returns {Promise<{installSkills: Array, updateSkills: Array, installCommands: Array, declinedSkills: Array, declinedCommands: Array}>}
+ * @param {Array} outdatedCommands - Array of {agent, displayName, paths, currentVersion, latestVersion, level, path}
+ * @returns {Promise<{installSkills: Array, updateSkills: Array, installCommands: Array, updateCommands: Array, declinedSkills: Array, declinedCommands: Array}>}
  */
-async function promptNewFeatureInstallation(missingSkills, outdatedSkills, missingCommands) {
+async function promptNewFeatureInstallation(missingSkills, outdatedSkills, missingCommands, outdatedCommands = []) {
   const msg = t().commands.update;
 
   // If nothing to do, return empty
-  if (missingSkills.length === 0 && outdatedSkills.length === 0 && missingCommands.length === 0) {
-    return { installSkills: [], updateSkills: [], installCommands: [], declinedSkills: [], declinedCommands: [] };
+  if (missingSkills.length === 0 && outdatedSkills.length === 0 && missingCommands.length === 0 && outdatedCommands.length === 0) {
+    return { installSkills: [], updateSkills: [], installCommands: [], updateCommands: [], declinedSkills: [], declinedCommands: [] };
   }
 
   console.log();
@@ -1306,7 +1365,7 @@ async function promptNewFeatureInstallation(missingSkills, outdatedSkills, missi
   console.log(chalk.cyan('━'.repeat(50)));
   console.log();
 
-  const result = { installSkills: [], updateSkills: [], installCommands: [], declinedSkills: [], declinedCommands: [] };
+  const result = { installSkills: [], updateSkills: [], installCommands: [], updateCommands: [], declinedSkills: [], declinedCommands: [] };
 
   // Handle missing Skills using unified prompt (consistent with init/configure)
   if (missingSkills.length > 0) {
@@ -1406,5 +1465,63 @@ async function promptNewFeatureInstallation(missingSkills, outdatedSkills, missi
     result.declinedCommands = missingAgents.filter(a => !installedAgents.includes(a));
   }
 
+  // Handle outdated Commands with checkbox selection (similar to Skills)
+  if (outdatedCommands.length > 0) {
+    console.log(chalk.yellow(msg.commandsOutdatedFor || 'Commands updates available for these AI tools:'));
+    for (const cmd of outdatedCommands) {
+      const levelLabel = cmd.level === 'user' ? 'user' : 'project';
+      const pathDisplay = cmd.path || getCommandsDirForAgent(cmd.agent, cmd.level);
+      console.log(chalk.gray(`  • ${cmd.displayName} (${levelLabel}: ${pathDisplay})`));
+      console.log(chalk.gray(`      ${cmd.currentVersion} → ${cmd.latestVersion}`));
+    }
+    console.log();
+
+    // Build checkbox choices with path info
+    const updateCmdChoices = outdatedCommands.map(cmd => {
+      const levelLabel = cmd.level === 'user' ? 'user' : 'project';
+      const pathDisplay = cmd.path || getCommandsDirForAgent(cmd.agent, cmd.level);
+      return {
+        name: `${cmd.displayName} ${chalk.gray(`(${levelLabel}: ${pathDisplay}) ${cmd.currentVersion} → ${cmd.latestVersion}`)}`,
+        value: cmd.agent,
+        checked: true  // Default checked for opt-out behavior
+      };
+    });
+
+    // Add skip option
+    updateCmdChoices.push(new inquirer.Separator());
+    updateCmdChoices.push({
+      name: chalk.gray(msg.skipCommandsUpdate || 'Skip Commands update'),
+      value: '__skip__'
+    });
+
+    const { selectedUpdateCmdAgents } = await inquirer.prompt([{
+      type: 'checkbox',
+      name: 'selectedUpdateCmdAgents',
+      message: msg.selectCommandsToUpdate || 'Select AI tools to update Commands for:',
+      choices: updateCmdChoices,
+      validate: (answer) => {
+        if (answer.includes('__skip__') && answer.length > 1) {
+          return msg.skipValidationError || 'Cannot select Skip with other options';
+        }
+        return true;
+      }
+    }]);
+
+    // Filter out skip and map to update info
+    const filteredUpdateCmdAgents = selectedUpdateCmdAgents.filter(a => a !== '__skip__');
+
+    if (filteredUpdateCmdAgents.length > 0) {
+      result.updateCommands = filteredUpdateCmdAgents.map(agent => {
+        const cmdInfo = outdatedCommands.find(c => c.agent === agent);
+        return {
+          agent,
+          level: cmdInfo.level,
+          path: cmdInfo.path
+        };
+      });
+    }
+    console.log();
+  }
+
   return result;
 }

package/src/commands/workflow.js

@@ -22,6 +22,8 @@ import {
 } from '../config/ai-agent-paths.js';
 import { setLanguage, isLanguageExplicitlySet } from '../i18n/messages.js';
 import { readManifest, isInitialized } from '../utils/copier.js';
+import { WorkflowExecutor } from '../utils/workflow-executor.js';
+import { WorkflowStateManager } from '../utils/workflow-state.js';
 
 /**
  * Workflow list command - list available and installed workflows
@@ -418,8 +420,270 @@ function cleanDescription(description) {
     .trim();
 }
 
+/**
+ * Workflow execute command - execute a workflow step by step
+ * @param {string} workflowName - Name of the workflow to execute
+ * @param {Object} options - Command options
+ */
+export async function workflowExecuteCommand(workflowName, options) {
+  const projectPath = process.cwd();
+
+  // Set UI language based on project's commit_language if initialized
+  if (!isLanguageExplicitlySet() && isInitialized(projectPath)) {
+    const manifest = readManifest(projectPath);
+    if (manifest?.options?.commit_language) {
+      const langMap = {
+        'traditional-chinese': 'zh-tw',
+        'simplified-chinese': 'zh-cn',
+        english: 'en',
+        bilingual: 'en'
+      };
+      const uiLang = langMap[manifest.options.commit_language] || 'en';
+      setLanguage(uiLang);
+    }
+  }
+
+  // Validate workflow name
+  if (!workflowName) {
+    console.log(chalk.red('Please specify a workflow name.'));
+    console.log(chalk.gray('Usage: uds workflow execute <workflow-name>'));
+    console.log();
+
+    const available = getAvailableWorkflowNames();
+    if (available.length > 0) {
+      console.log(chalk.gray('Available workflows:'));
+      for (const name of available) {
+        console.log(chalk.gray(`  - ${name}`));
+      }
+    }
+    return;
+  }
+
+  // Check if workflow exists
+  const content = getWorkflowContent(workflowName);
+  if (!content) {
+    console.log(chalk.red(`Workflow not found: ${workflowName}`));
+    const available = getAvailableWorkflowNames();
+    console.log(chalk.gray(`Available workflows: ${available.join(', ')}`));
+    return;
+  }
+
+  // Determine target AI tool
+  let targetTool = options.tool || 'claude-code';
+  const supportedTools = getWorkflowsSupportedAgents();
+
+  if (!supportedTools.includes(targetTool)) {
+    console.log(chalk.red(`AI tool '${targetTool}' does not support workflows.`));
+    console.log(chalk.gray(`Supported tools: ${supportedTools.join(', ')}`));
+    return;
+  }
+
+  // Check for resume mode
+  if (options.resume) {
+    const stateManager = new WorkflowStateManager(workflowName, projectPath);
+    if (!stateManager.exists()) {
+      console.log(chalk.yellow('No saved state found for this workflow.'));
+      console.log(chalk.gray('Starting fresh execution...'));
+      console.log();
+      options.resume = false;
+    } else if (!stateManager.canResume()) {
+      console.log(chalk.yellow('Workflow state exists but cannot be resumed.'));
+      console.log(chalk.gray('Starting fresh execution...'));
+      console.log();
+      options.resume = false;
+    }
+  }
+
+  // Create executor
+  const executor = new WorkflowExecutor({
+    aiTool: targetTool,
+    projectPath,
+    verbose: options.verbose || false,
+    dryRun: options.dryRun || false,
+    interactive: !options.yes
+  });
+
+  // Execute or resume
+  let result;
+  if (options.resume) {
+    result = await executor.resume(workflowName);
+  } else {
+    result = await executor.execute(workflowName, {
+      restart: options.restart || false
+    });
+  }
+
+  // Handle result
+  if (!result.success) {
+    if (result.paused) {
+      console.log();
+      console.log(chalk.yellow('Workflow paused.'));
+      console.log(chalk.gray('Run with --resume to continue from where you left off:'));
+      console.log(chalk.gray(`  uds workflow execute ${workflowName} --resume`));
+    } else {
+      console.log();
+      console.log(chalk.red(`Workflow execution failed: ${result.error}`));
+
+      if (result.failedStep) {
+        console.log(chalk.gray(`Failed at step: ${result.failedStep}`));
+      }
+    }
+    return;
+  }
+
+  // Success
+  if (result.dryRun) {
+    console.log();
+    console.log(chalk.cyan('Dry run complete. No changes were made.'));
+    console.log(chalk.gray('Remove --dry-run to execute the workflow.'));
+  }
+
+  console.log();
+}
+
+/**
+ * Workflow status command - show current execution status
+ * @param {string} workflowName - Name of the workflow
+ * @param {Object} options - Command options
+ */
+export async function workflowStatusCommand(workflowName, _options) {
+  const projectPath = process.cwd();
+
+  if (!workflowName) {
+    // List all workflows with saved state
+    console.log();
+    console.log(chalk.bold('📊 Workflow Execution Status'));
+    console.log(chalk.gray('─'.repeat(50)));
+    console.log();
+
+    const available = getAvailableWorkflowNames();
+    let foundAny = false;
+
+    for (const name of available) {
+      const stateManager = new WorkflowStateManager(name, projectPath);
+      if (stateManager.exists()) {
+        stateManager.load();
+        const summary = stateManager.getSummary();
+
+        if (summary) {
+          foundAny = true;
+          const statusIcon = getStatusIcon(summary.status);
+          console.log(`  ${statusIcon} ${chalk.cyan(name)}`);
+          console.log(`    Status: ${summary.status}`);
+          console.log(`    Progress: ${summary.progress.completed}/${summary.progress.total} steps`);
+
+          if (summary.currentStepId) {
+            console.log(`    Current: ${summary.currentStepId}`);
+          }
+
+          console.log();
+        }
+      }
+    }
+
+    if (!foundAny) {
+      console.log(chalk.gray('No workflows currently in progress.'));
+      console.log();
+    }
+
+    return;
+  }
+
+  // Show status for specific workflow
+  const stateManager = new WorkflowStateManager(workflowName, projectPath);
+
+  if (!stateManager.exists()) {
+    console.log(chalk.yellow(`No execution state found for workflow: ${workflowName}`));
+    return;
+  }
+
+  stateManager.load();
+  const summary = stateManager.getSummary();
+  const state = stateManager.getState();
+
+  console.log();
+  console.log(chalk.bold(`📊 Workflow Status: ${workflowName}`));
+  console.log(chalk.gray('─'.repeat(50)));
+  console.log();
+
+  console.log(`Status: ${getStatusIcon(summary.status)} ${summary.status}`);
+  console.log(`Progress: ${summary.progress.completed}/${summary.progress.total} steps (${summary.progress.percentage}%)`);
+
+  if (summary.startedAt) {
+    console.log(`Started: ${summary.startedAt}`);
+  }
+
+  if (summary.completedAt) {
+    console.log(`Completed: ${summary.completedAt}`);
+  }
+
+  console.log();
+  console.log(chalk.bold('Steps:'));
+  console.log();
+
+  for (const [stepId, stepState] of Object.entries(state.steps)) {
+    const statusIcon = getStepStatusIcon(stepState.status);
+    console.log(`  ${statusIcon} ${stepId}: ${stepState.status}`);
+
+    if (stepState.error) {
+      console.log(chalk.red(`    Error: ${stepState.error}`));
+    }
+  }
+
+  console.log();
+
+  if (stateManager.canResume()) {
+    console.log(chalk.cyan('To resume: uds workflow execute ' + workflowName + ' --resume'));
+    console.log();
+  }
+}
+
+/**
+ * Get status icon for workflow status
+ * @param {string} status - Workflow status
+ * @returns {string} Icon
+ */
+function getStatusIcon(status) {
+  switch (status) {
+    case 'completed':
+      return chalk.green('✓');
+    case 'in_progress':
+      return chalk.yellow('◐');
+    case 'paused':
+      return chalk.blue('⏸');
+    case 'failed':
+      return chalk.red('✗');
+    default:
+      return chalk.gray('○');
+  }
+}
+
+/**
+ * Get status icon for step status
+ * @param {string} status - Step status
+ * @returns {string} Icon
+ */
+function getStepStatusIcon(status) {
+  switch (status) {
+    case 'completed':
+      return chalk.green('✓');
+    case 'in_progress':
+      return chalk.yellow('◐');
+    case 'pending':
+      return chalk.gray('○');
+    case 'failed':
+      return chalk.red('✗');
+    case 'skipped':
+      return chalk.gray('⊘');
+    default:
+      return chalk.gray('○');
+  }
+}
+
 export default {
   workflowListCommand,
   workflowInstallCommand,
-  workflowInfoCommand
+  workflowInfoCommand,
+  workflowExecuteCommand,
+  workflowStatusCommand
 };