@polymorphism-tech/morph-spec 3.2.0 → 4.2.0

package/src/commands/{detect-agents.js → project/detect-agents.js}

@@ -1,178 +1,178 @@
-import { readFileSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import chalk from 'chalk';
-import { logger } from '../utils/logger.js';
-import { analyzeRequestComplexity } from '../lib/complexity-analyzer.js';
-import { LearningSystem } from '../lib/learning-system.js';
-import { loadStandardsForAgent, getStandardsListForAgent } from '../lib/standards-context-injector.js';
-import { resolveAgentsConfigPath } from '../lib/stack-resolver.js';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const frameworkRoot = join(__dirname, '..', '..');
-
-function loadAgentsConfig() {
-  try {
-    const configPath = resolveAgentsConfigPath(frameworkRoot);
-    const content = readFileSync(configPath, 'utf8');
-    return JSON.parse(content);
-  } catch (err) {
-    logger.error(`Failed to load agents config: ${err.message}`);
-    process.exit(1);
-  }
-}
-
-function detectAgents(userInput, config) {
-  const input = userInput.toLowerCase();
-
-  // MORPH 3.0 Hierarchical: agents is a flat object, not arrays
-  const allAgents = Object.entries(config.agents || {})
-    .filter(([id]) => !id.startsWith('_comment'))
-    .map(([id, agent]) => ({ id, ...agent }));
-
-  // Core agents = always_active agents (typically Tier 1)
-  const coreAgents = allAgents.filter(a => a.always_active === true);
-  const coreIds = coreAgents.map(a => a.id);
-
-  // Specialist agents = keyword-matched agents
-  const specialistMatches = [];
-
-  for (const agent of allAgents) {
-    if (agent.always_active) continue; // Skip core agents
-
-    // MORPH 3.0.1: Check negative keywords first — if any match, skip agent entirely
-    const negativeKeywords = agent.negativeKeywords || [];
-    const hasNegativeMatch = negativeKeywords.some(neg =>
-      input.includes(neg.toLowerCase())
-    );
-    if (hasNegativeMatch) continue;
-
-    // MORPH 3.0: keywords is directly on agent, not nested in autoActivation
-    const keywords = agent.keywords || [];
-    const matchedKeywords = [];
-
-    for (const keyword of keywords) {
-      if (input.includes(keyword.toLowerCase())) {
-        matchedKeywords.push(keyword);
-      }
-    }
-
-    if (matchedKeywords.length > 0) {
-      specialistMatches.push({
-        id: agent.id,
-        name: agent.title || agent.id, // Use title as name
-        emoji: agent.teammate?.icon || '🤖',
-        matchedKeywords,
-        matchCount: matchedKeywords.length
-      });
-    }
-  }
-
-  specialistMatches.sort((a, b) => b.matchCount - a.matchCount);
-
-  const specialistIds = specialistMatches.map(m => m.id);
-  const allIds = [...new Set([...coreIds, ...specialistIds])];
-
-  return {
-    core: coreIds,
-    specialists: specialistIds,
-    all: allIds,
-    matches: specialistMatches,
-    input: userInput
-  };
-}
-
-function formatVerbose(result) {
-  logger.blank();
-  logger.header('AGENT DETECTION RESULT');
-  logger.info(`Input: ${chalk.white(result.input)}`);
-  logger.blank();
-
-  logger.header('CORE AGENTS (always active)');
-  result.core.forEach(id => {
-    logger.info(`  ${chalk.green('✓')} ${id}`);
-  });
-  logger.blank();
-
-  if (result.matches.length > 0) {
-    logger.header('SPECIALIST AGENTS (keyword matched)');
-    result.matches.forEach(match => {
-      logger.info(`  ${match.emoji} ${chalk.yellow(match.name)} (${match.matchCount} matches)`);
-      logger.dim(`     Keywords: ${match.matchedKeywords.join(', ')}`);
-    });
-  } else {
-    logger.dim('  No specialist agents matched');
-  }
-
-  logger.blank();
-  logger.info(`Total: ${chalk.cyan(result.all.length)} agents activated`);
-  logger.blank();
-}
-
-export { detectAgents, loadAgentsConfig };
-
-export function detectAgentsCommand(input, options) {
-  const userInput = Array.isArray(input) ? input.join(' ') : input;
-
-  if (!userInput) {
-    logger.error('User input is required');
-    logger.dim('Usage: morph-spec detect-agents "your feature description"');
-    process.exit(1);
-  }
-
-  const config = loadAgentsConfig();
-  const result = detectAgents(userInput, config);
-
-  // Enrich with complexity analysis
-  try {
-    result.complexity = analyzeRequestComplexity(userInput);
-    result.suggestedWorkflow = result.complexity.workflow;
-  } catch {
-    result.complexity = null;
-    result.suggestedWorkflow = 'standard';
-  }
-
-  // Enrich with learning suggestions
-  try {
-    const learner = new LearningSystem('.');
-    result.learningSuggestions = learner.getAllSuggestions();
-  } catch {
-    result.learningSuggestions = null;
-  }
-
-  // Enrich with skill paths for each detected agent
-  const allAgents = [...(config.agents.core || []), ...(config.agents.specialists || [])];
-  result.skillPaths = result.all
-    .map(id => {
-      const agent = allAgents.find(a => a.id === id);
-      return agent?.skillPath || null;
-    })
-    .filter(Boolean);
-
-  // Enrich with standards context when JSON output requested
-  if (options.json) {
-    const projectPath = process.cwd();
-    result.standardsSummary = {};
-
-    for (const agentId of result.all) {
-      const standardsList = getStandardsListForAgent(agentId);
-      const { fullContent } = loadStandardsForAgent(agentId, projectPath);
-
-      result.standardsSummary[agentId] = {
-        standards: standardsList,
-        fullContent: fullContent,
-        count: standardsList.length
-      };
-    }
-  }
-
-  if (options.json) {
-    console.log(JSON.stringify(result, null, 2));
-  } else if (options.verbose) {
-    formatVerbose(result);
-  } else if (options.idsOnly) {
-    result.all.forEach(id => console.log(id));
-  } else {
-    console.log(JSON.stringify(result.all));
-  }
-}
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import chalk from 'chalk';
+import { logger } from '../../utils/logger.js';
+import { analyzeRequestComplexity } from '../../lib/analysis/complexity-analyzer.js';
+import { LearningSystem } from '../../lib/learning/learning-system.js';
+import { loadStandardsForAgent, getStandardsListForAgent } from '../../lib/standards/standards-context-injector.js';
+import { resolveAgentsConfigPath } from '../../lib/stacks/stack-resolver.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const frameworkRoot = join(__dirname, '..', '..');
+
+function loadAgentsConfig() {
+  try {
+    const configPath = resolveAgentsConfigPath(frameworkRoot);
+    const content = readFileSync(configPath, 'utf8');
+    return JSON.parse(content);
+  } catch (err) {
+    logger.error(`Failed to load agents config: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+function detectAgents(userInput, config) {
+  const input = userInput.toLowerCase();
+
+  // MORPH 3.0 Hierarchical: agents is a flat object, not arrays
+  const allAgents = Object.entries(config.agents || {})
+    .filter(([id]) => !id.startsWith('_comment'))
+    .map(([id, agent]) => ({ id, ...agent }));
+
+  // Core agents = always_active agents (typically Tier 1)
+  const coreAgents = allAgents.filter(a => a.always_active === true);
+  const coreIds = coreAgents.map(a => a.id);
+
+  // Specialist agents = keyword-matched agents
+  const specialistMatches = [];
+
+  for (const agent of allAgents) {
+    if (agent.always_active) continue; // Skip core agents
+
+    // MORPH 3.0.1: Check negative keywords first — if any match, skip agent entirely
+    const negativeKeywords = agent.negativeKeywords || [];
+    const hasNegativeMatch = negativeKeywords.some(neg =>
+      input.includes(neg.toLowerCase())
+    );
+    if (hasNegativeMatch) continue;
+
+    // MORPH 3.0: keywords is directly on agent, not nested in autoActivation
+    const keywords = agent.keywords || [];
+    const matchedKeywords = [];
+
+    for (const keyword of keywords) {
+      if (input.includes(keyword.toLowerCase())) {
+        matchedKeywords.push(keyword);
+      }
+    }
+
+    if (matchedKeywords.length > 0) {
+      specialistMatches.push({
+        id: agent.id,
+        name: agent.title || agent.id, // Use title as name
+        emoji: agent.teammate?.icon || '🤖',
+        matchedKeywords,
+        matchCount: matchedKeywords.length
+      });
+    }
+  }
+
+  specialistMatches.sort((a, b) => b.matchCount - a.matchCount);
+
+  const specialistIds = specialistMatches.map(m => m.id);
+  const allIds = [...new Set([...coreIds, ...specialistIds])];
+
+  return {
+    core: coreIds,
+    specialists: specialistIds,
+    all: allIds,
+    matches: specialistMatches,
+    input: userInput
+  };
+}
+
+function formatVerbose(result) {
+  logger.blank();
+  logger.header('AGENT DETECTION RESULT');
+  logger.info(`Input: ${chalk.white(result.input)}`);
+  logger.blank();
+
+  logger.header('CORE AGENTS (always active)');
+  result.core.forEach(id => {
+    logger.info(`  ${chalk.green('✓')} ${id}`);
+  });
+  logger.blank();
+
+  if (result.matches.length > 0) {
+    logger.header('SPECIALIST AGENTS (keyword matched)');
+    result.matches.forEach(match => {
+      logger.info(`  ${match.emoji} ${chalk.yellow(match.name)} (${match.matchCount} matches)`);
+      logger.dim(`     Keywords: ${match.matchedKeywords.join(', ')}`);
+    });
+  } else {
+    logger.dim('  No specialist agents matched');
+  }
+
+  logger.blank();
+  logger.info(`Total: ${chalk.cyan(result.all.length)} agents activated`);
+  logger.blank();
+}
+
+export { detectAgents, loadAgentsConfig };
+
+export function detectAgentsCommand(input, options) {
+  const userInput = Array.isArray(input) ? input.join(' ') : input;
+
+  if (!userInput) {
+    logger.error('User input is required');
+    logger.dim('Usage: morph-spec detect-agents "your feature description"');
+    process.exit(1);
+  }
+
+  const config = loadAgentsConfig();
+  const result = detectAgents(userInput, config);
+
+  // Enrich with complexity analysis
+  try {
+    result.complexity = analyzeRequestComplexity(userInput);
+    result.suggestedWorkflow = result.complexity.workflow;
+  } catch {
+    result.complexity = null;
+    result.suggestedWorkflow = 'standard';
+  }
+
+  // Enrich with learning suggestions
+  try {
+    const learner = new LearningSystem('.');
+    result.learningSuggestions = learner.getAllSuggestions();
+  } catch {
+    result.learningSuggestions = null;
+  }
+
+  // Enrich with skill paths for each detected agent
+  const allAgents = [...(config.agents.core || []), ...(config.agents.specialists || [])];
+  result.skillPaths = result.all
+    .map(id => {
+      const agent = allAgents.find(a => a.id === id);
+      return agent?.skillPath || null;
+    })
+    .filter(Boolean);
+
+  // Enrich with standards context when JSON output requested
+  if (options.json) {
+    const projectPath = process.cwd();
+    result.standardsSummary = {};
+
+    for (const agentId of result.all) {
+      const standardsList = getStandardsListForAgent(agentId);
+      const { fullContent } = loadStandardsForAgent(agentId, projectPath);
+
+      result.standardsSummary[agentId] = {
+        standards: standardsList,
+        fullContent: fullContent,
+        count: standardsList.length
+      };
+    }
+  }
+
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else if (options.verbose) {
+    formatVerbose(result);
+  } else if (options.idsOnly) {
+    result.all.forEach(id => console.log(id));
+  } else {
+    console.log(JSON.stringify(result.all));
+  }
+}

package/src/commands/project/detect-workflow.js

@@ -0,0 +1,174 @@
+/**
+ * MORPH-SPEC Detect Workflow Command
+ *
+ * Analyzes a feature request and detects the most appropriate workflow
+ *
+ * Usage:
+ *   morph-spec detect-workflow "add pagination to users table"
+ */
+
+import chalk from 'chalk';
+import { detectWorkflow, getWorkflowConfig } from '../../core/workflows/workflow-detector.js';
+
+/**
+ * Main command handler
+ * @param {Array<string>} input - User request words
+ * @param {Object} options - Command options
+ */
+export async function detectWorkflowCommand(input, options = {}) {
+  const userRequest = input.join(' ');
+
+  if (!userRequest || userRequest.trim().length === 0) {
+    console.log(chalk.red('\n✗ Error: Please provide a feature request'));
+    console.log(chalk.gray('\nUsage: morph-spec detect-workflow "add pagination to users table"\n'));
+    process.exit(1);
+  }
+
+  console.log(chalk.cyan('\n╔════════════════════════════════════════════════╗'));
+  console.log(chalk.cyan('║     MORPH-SPEC WORKFLOW DETECTION             ║'));
+  console.log(chalk.cyan('╚════════════════════════════════════════════════╝\n'));
+
+  console.log(chalk.gray('Analyzing request:'), `"${userRequest}"`);
+  console.log('');
+
+  try {
+    // Detect workflow
+    const result = await detectWorkflow({
+      userRequest,
+      projectPath: options.projectPath || '.'
+    });
+
+    // Load workflow config for details
+    const workflowConfig = getWorkflowConfig(result.workflowId);
+
+    if (options.json) {
+      // JSON output mode
+      console.log(JSON.stringify({
+        workflowId: result.workflowId,
+        workflowName: workflowConfig?.name || result.workflowId,
+        confidence: result.confidence,
+        matchedKeywords: result.matchedKeywords,
+        estimatedComplexity: result.estimatedComplexity,
+        reasoning: result.reasoning,
+        alternativeWorkflows: result.alternativeWorkflows,
+        workflowConfig: workflowConfig
+      }, null, 2));
+      return;
+    }
+
+    // Human-readable output
+    const confidencePercent = Math.round(result.confidence * 100);
+    console.log(chalk.green(`✓ Detected Workflow: ${chalk.bold(workflowConfig?.name || result.workflowId)}`));
+    console.log(chalk.gray(`  Confidence: ${confidencePercent}%\n`));
+
+    // Criteria Match
+    console.log(chalk.cyan('Criteria Match:'));
+    if (result.matchedKeywords.length > 0) {
+      console.log(chalk.green(`  ✓ Keywords: ${result.matchedKeywords.join(', ')}`));
+    }
+    console.log(chalk.gray(`  • Estimated complexity: ${result.estimatedComplexity.files} files, ~${result.estimatedComplexity.lines} lines`));
+    if (result.estimatedComplexity.components > 0) {
+      console.log(chalk.gray(`  • Components: ${result.estimatedComplexity.components}`));
+    }
+    if (result.estimatedComplexity.hasInfra) {
+      console.log(chalk.yellow(`  ⚠ Infrastructure keywords detected`));
+    }
+    console.log('');
+
+    // Workflow Details
+    if (workflowConfig) {
+      console.log(chalk.cyan('Workflow Description:'));
+      console.log(chalk.gray(`  ${workflowConfig.description}\n`));
+
+      // Phases to Run
+      console.log(chalk.cyan('Phases to Run:'));
+      const phasesToRun = workflowConfig.phases.run || [];
+      phasesToRun.forEach((phase, index) => {
+        const pausePoint = workflowConfig.pausePoints?.find(p => p.phase === phase);
+        const pauseIndicator = pausePoint ? chalk.yellow(' ⏸️  Pause for approval') : '';
+        console.log(chalk.white(`  ${index + 1}. ${phase.toUpperCase()}${pauseIndicator}`));
+        if (pausePoint) {
+          console.log(chalk.gray(`     Question: "${pausePoint.question}"`));
+        }
+      });
+      console.log('');
+
+      // Phases Skipped
+      if (workflowConfig.phases.skip && workflowConfig.phases.skip.length > 0) {
+        console.log(chalk.cyan('Phases Skipped:'));
+        workflowConfig.phases.skip.forEach(phase => {
+          const reason = getSkipReason(phase, workflowConfig);
+          console.log(chalk.gray(`  ✗ ${phase.toUpperCase()}${reason ? ` - ${reason}` : ''}`));
+        });
+        console.log('');
+      }
+
+      // Combined Phases
+      if (workflowConfig.phases.combined && Object.keys(workflowConfig.phases.combined).length > 0) {
+        console.log(chalk.cyan('Combined Phases:'));
+        for (const [combinedName, phases] of Object.entries(workflowConfig.phases.combined)) {
+          console.log(chalk.gray(`  → ${combinedName.toUpperCase()} combines: ${phases.join(', ')}`));
+        }
+        console.log('');
+      }
+
+      // Required Outputs
+      if (workflowConfig.outputs?.required && workflowConfig.outputs.required.length > 0) {
+        console.log(chalk.cyan('Required Outputs:'));
+        workflowConfig.outputs.required.forEach(output => {
+          console.log(chalk.white(`  • ${output}`));
+        });
+        console.log('');
+      }
+    }
+
+    // Alternative Workflows
+    if (result.alternativeWorkflows.length > 0) {
+      console.log(chalk.cyan('Alternative Workflows:'));
+      result.alternativeWorkflows.forEach(alt => {
+        const altPercent = Math.round(alt.confidence * 100);
+        console.log(chalk.gray(`  - ${alt.workflowId} (${altPercent}%): ${alt.reason}`));
+      });
+      console.log('');
+    }
+
+    // How to Override
+    console.log(chalk.cyan('To override detected workflow:'));
+    console.log(chalk.white(`  morph-spec state set <feature-name> workflow <workflow-id>`));
+    console.log('');
+
+    console.log(chalk.gray('─'.repeat(50)));
+    console.log(chalk.gray('Available workflows: fast-track, standard, full-morph, design-impl, ui-refresh'));
+    console.log('');
+
+  } catch (error) {
+    console.log(chalk.red('\n✗ Workflow detection failed:'));
+    console.log(chalk.red(error.message));
+    if (options.verbose) {
+      console.log(chalk.gray('\nStack trace:'));
+      console.log(chalk.gray(error.stack));
+    }
+    console.log('');
+    process.exit(1);
+  }
+}
+
+/**
+ * Get skip reason for a phase
+ * @param {string} phase - Phase name
+ * @param {Object} workflowConfig - Workflow config
+ * @returns {string} Skip reason
+ */
+function getSkipReason(phase, workflowConfig) {
+  const reasons = {
+    'setup': 'context already loaded',
+    'uiux': 'no significant UI changes',
+    'clarify': 'spec is clear for this type',
+    'sync': 'tactical decisions, not strategic',
+    'proposal': 'combined into quick-analysis',
+    'design': 'design not needed for visual-only changes',
+    'tasks': 'simple enough for direct implementation'
+  };
+
+  return reasons[phase] || '';
+}