@polymorphism-tech/morph-spec 4.3.7 → 4.6.0

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

@@ -1,174 +0,0 @@
-/**
- * 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] || '';
-}

package/src/commands/threads/thread-template.js

@@ -1,103 +0,0 @@
-/**
- * Thread Template CLI command — Thread type management
- *
- * Usage:
- *   morph-spec thread-template list
- *   morph-spec thread-template use <type> --feature=<feature>
- */
-
-import chalk from 'chalk';
-import { THREAD_TYPES } from '../../lib/threads/thread-manager.js';
-
-const THREAD_TYPE_INFO = {
-  [THREAD_TYPES.BASE]: {
-    name: 'B-Thread (Base)',
-    description: 'Standard single-agent thread. Sequential execution, all approval gates required.',
-    useCase: 'Default for simple and medium features',
-    phases: 'All standard phases',
-    approvalGates: 'Manual (all)',
-    maxConcurrent: 1
-  },
-  [THREAD_TYPES.PARALLEL]: {
-    name: 'P-Thread (Parallel)',
-    description: 'Multiple agents run simultaneously on different feature domains.',
-    useCase: 'Full-stack features with independent backend/frontend/infra work',
-    phases: 'All phases (parallel IMPLEMENT)',
-    approvalGates: 'Manual (all)',
-    maxConcurrent: 5
-  },
-  [THREAD_TYPES.FUSION]: {
-    name: 'F-Thread (Fusion)',
-    description: 'N agents independently generate solutions; best-of-N result is selected.',
-    useCase: 'High-uncertainty decisions, critical architecture choices, prototype evaluation',
-    phases: 'DESIGN → parallel IMPLEMENT → AGGREGATE → SYNC',
-    approvalGates: 'Manual select (or auto best-of-n)',
-    maxConcurrent: 3
-  },
-  [THREAD_TYPES.LONG_RUNNING]: {
-    name: 'L-Thread (Long-Running)',
-    description: 'Autonomous agent with stop hooks every 30 minutes for validation.',
-    useCase: 'Large scope features (>10 files), autonomous implementation without interruption',
-    phases: 'IMPLEMENT (continuous) with periodic validation',
-    approvalGates: 'Auto (stop hooks validate)',
-    maxConcurrent: 1
-  },
-  [THREAD_TYPES.ZERO_TOUCH]: {
-    name: 'Z-Thread (Zero-Touch)',
-    description: 'Fully autonomous execution. Auto-approves all gates, auto-commits on success.',
-    useCase: 'Maximum-trust features with >95% checkpoint pass rate',
-    phases: 'All phases (auto-approved)',
-    approvalGates: 'Auto (trust-based)',
-    maxConcurrent: 1
-  }
-};
-
-export async function threadTemplateListCommand(options) {
-  console.log(chalk.cyan('\n  Thread Types\n'));
-  console.log('  ' + '─'.repeat(70));
-
-  for (const [type, info] of Object.entries(THREAD_TYPE_INFO)) {
-    console.log(`\n  ${chalk.bold(info.name)}`);
-    console.log(`  ${info.description}`);
-    console.log(`  ${chalk.gray('Use case:')} ${info.useCase}`);
-    console.log(`  ${chalk.gray('Phases:')} ${info.phases}`);
-    console.log(`  ${chalk.gray('Gates:')} ${info.approvalGates}`);
-    console.log(`  ${chalk.gray('Max concurrent:')} ${info.maxConcurrent}`);
-  }
-
-  console.log('\n  ' + '─'.repeat(70));
-  console.log(chalk.gray('\n  Set thread type: morph-spec thread-template use <type> --feature=<feature>\n'));
-}
-
-export async function threadTemplateUseCommand(type, options) {
-  if (!options.feature) {
-    console.error(chalk.red('--feature is required'));
-    process.exit(1);
-  }
-
-  if (!THREAD_TYPE_INFO[type]) {
-    console.error(chalk.red(`Unknown thread type: ${type}`));
-    console.error(chalk.gray(`Valid types: ${Object.keys(THREAD_TYPE_INFO).join(', ')}`));
-    process.exit(1);
-  }
-
-  const info = THREAD_TYPE_INFO[type];
-
-  // Special checks
-  if (type === THREAD_TYPES.ZERO_TOUCH) {
-    console.log(chalk.yellow('\n  ⚠ Z-Thread requires maximum trust level (>95% checkpoint pass rate)'));
-    console.log(chalk.gray('  Check trust: morph-spec trust status\n'));
-  }
-
-  // Update feature state with thread type
-  try {
-    const { updateFeature } = await import('../../core/state/state-manager.js');
-    await updateFeature(options.feature, 'threadType', type);
-    console.log(chalk.green(`\n  ✓ Thread type set: ${type} for feature: ${options.feature}`));
-    console.log(`  ${info.name}: ${info.description}`);
-    console.log('');
-  } catch (err) {
-    console.error(chalk.red(`  Error updating state: ${err.message}`));
-    process.exit(1);
-  }
-}

package/src/commands/threads/threads.js

@@ -1,261 +0,0 @@
-/**
- * Threads CLI command — Thread lifecycle management
- *
- * Usage:
- *   morph-spec threads list [--feature=<f>] [--status=<s>]
- *   morph-spec threads status <id>
- *   morph-spec threads kill <id>
- *   morph-spec threads analytics [--feature=<f>]
- *   morph-spec threads wait-all <feature>
- *   morph-spec threads wait-any <feature>
- */
-
-import chalk from 'chalk';
-import {
-  listThreads, getThread, killThread, getThreadAnalytics,
-  THREAD_STATUS, THREAD_TYPES
-} from '../../lib/threads/thread-manager.js';
-import { generateAsciiChart, generateTimelineChart } from '../../lib/analytics/analytics-engine.js';
-
-const STATUS_COLORS = {
-  [THREAD_STATUS.PENDING]: chalk.yellow,
-  [THREAD_STATUS.RUNNING]: chalk.cyan,
-  [THREAD_STATUS.COMPLETED]: chalk.green,
-  [THREAD_STATUS.FAILED]: chalk.red,
-  [THREAD_STATUS.KILLED]: chalk.gray
-};
-
-const TYPE_ICONS = {
-  [THREAD_TYPES.BASE]: '◆',
-  [THREAD_TYPES.PARALLEL]: '⫸',
-  [THREAD_TYPES.FUSION]: '⊕',
-  [THREAD_TYPES.LONG_RUNNING]: '∞',
-  [THREAD_TYPES.ZERO_TOUCH]: '⚡'
-};
-
-function formatDuration(seconds) {
-  if (!seconds) return '—';
-  if (seconds < 60) return `${seconds}s`;
-  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
-  return `${Math.floor(seconds / 3600)}h ${Math.floor((seconds % 3600) / 60)}m`;
-}
-
-/**
- * List threads
- */
-export async function threadsListCommand(options) {
-  try {
-    const threads = listThreads({
-      feature: options.feature,
-      status: options.status,
-      type: options.type
-    });
-
-    if (threads.length === 0) {
-      console.log(chalk.gray('No threads found.'));
-      return;
-    }
-
-    console.log(chalk.cyan(`\n  Threads (${threads.length})\n`));
-    console.log(
-      '  ' + 'ID'.padEnd(10) + ' ' +
-      'Type'.padEnd(14) + ' ' +
-      'Status'.padEnd(12) + ' ' +
-      'Feature'.padEnd(20) + ' ' +
-      'Agent'.padEnd(20) + ' ' +
-      'Duration'
-    );
-    console.log('  ' + '─'.repeat(90));
-
-    for (const t of threads) {
-      const icon = TYPE_ICONS[t.type] || '◆';
-      const colorFn = STATUS_COLORS[t.status] || chalk.white;
-      const shortId = t.id.substring(0, 8);
-
-      console.log(
-        '  ' +
-        chalk.gray(shortId) + ' ' +
-        `${icon} ${t.type}`.padEnd(14) + ' ' +
-        colorFn(t.status.padEnd(12)) + ' ' +
-        (t.feature || '—').padEnd(20) + ' ' +
-        (t.agent || '—').padEnd(20) + ' ' +
-        formatDuration(t.duration)
-      );
-    }
-    console.log('');
-  } catch (err) {
-    console.error(chalk.red(`Error: ${err.message}`));
-    process.exit(1);
-  }
-}
-
-/**
- * Show thread status detail
- */
-export async function threadsStatusCommand(id) {
-  try {
-    const thread = getThread(id);
-    if (!thread) {
-      console.error(chalk.red(`Thread not found: ${id}`));
-      process.exit(1);
-    }
-
-    const colorFn = STATUS_COLORS[thread.status] || chalk.white;
-    const icon = TYPE_ICONS[thread.type] || '◆';
-
-    console.log(chalk.cyan('\n  Thread Detail\n'));
-    console.log(`  ID:       ${chalk.gray(thread.id)}`);
-    console.log(`  Type:     ${icon} ${thread.type}`);
-    console.log(`  Status:   ${colorFn(thread.status)}`);
-    console.log(`  Feature:  ${thread.feature || '—'}`);
-    console.log(`  Agent:    ${thread.agent || '—'}`);
-    console.log(`  Mission:  ${thread.mission || '—'}`);
-    console.log(`  Created:  ${thread.createdAt}`);
-    console.log(`  Started:  ${thread.startedAt || '—'}`);
-    console.log(`  Ended:    ${thread.completedAt || '—'}`);
-    console.log(`  Duration: ${formatDuration(thread.duration)}`);
-
-    if (thread.metrics) {
-      console.log('\n  Metrics:');
-      console.log(`    Tool calls:     ${thread.metrics.toolCalls || 0}`);
-      console.log(`    Tokens used:    ${(thread.metrics.tokensUsed || 0).toLocaleString()}`);
-      console.log(`    Checkpoints OK: ${thread.metrics.checkpointsPassed || 0}`);
-      console.log(`    Checkpoints KO: ${thread.metrics.checkpointsFailed || 0}`);
-    }
-
-    if (thread.events?.length > 0) {
-      console.log(`\n  Recent events (${thread.events.length}):`);
-      thread.events.slice(-5).forEach(e => {
-        console.log(`    ${chalk.gray(e.timestamp)} ${e.type}`);
-      });
-    }
-
-    if (thread.failureReason) {
-      console.log(`\n  ${chalk.red('Failure:')} ${thread.failureReason}`);
-    }
-    console.log('');
-  } catch (err) {
-    console.error(chalk.red(`Error: ${err.message}`));
-    process.exit(1);
-  }
-}
-
-/**
- * Kill a thread
- */
-export async function threadsKillCommand(id) {
-  try {
-    const thread = killThread(id);
-    console.log(chalk.yellow(`✓ Thread ${id.substring(0, 8)} killed.`));
-    console.log(`  Status: ${thread.status} | Duration: ${formatDuration(thread.duration)}`);
-  } catch (err) {
-    console.error(chalk.red(`Error: ${err.message}`));
-    process.exit(1);
-  }
-}
-
-/**
- * Show threads analytics dashboard
- */
-export async function threadsAnalyticsCommand(options) {
-  try {
-    const feature = options.feature;
-    if (!feature) {
-      console.error(chalk.red('--feature is required for analytics'));
-      process.exit(1);
-    }
-
-    const analytics = getThreadAnalytics(feature);
-
-    console.log(chalk.cyan(`\n  Thread Analytics — ${feature}\n`));
-    console.log(`  Total threads:   ${analytics.total}`);
-    console.log(`  By status:`);
-    for (const [status, count] of Object.entries(analytics.byStatus)) {
-      const colorFn = STATUS_COLORS[status] || chalk.white;
-      console.log(`    ${colorFn(status.padEnd(12))} ${count}`);
-    }
-
-    console.log('\n  By type:');
-    for (const [type, count] of Object.entries(analytics.byType)) {
-      const icon = TYPE_ICONS[type] || '◆';
-      console.log(`    ${icon} ${type.padEnd(14)} ${count}`);
-    }
-
-    console.log(`\n  Avg duration:    ${formatDuration(analytics.avgDuration)}`);
-    console.log(`  Total tool calls: ${analytics.totalToolCalls}`);
-    console.log(`  Checkpoint pass rate: ${Math.round(analytics.checkpointPassRate * 100)}%`);
-
-    if (analytics.total > 0) {
-      const statusChart = generateAsciiChart(analytics.byStatus, { title: 'Threads by Status' });
-      console.log('\n' + statusChart);
-    }
-    console.log('');
-  } catch (err) {
-    console.error(chalk.red(`Error: ${err.message}`));
-    process.exit(1);
-  }
-}
-
-/**
- * Wait for all threads in a feature to complete
- */
-export async function threadsWaitAllCommand(feature, options) {
-  const timeoutMs = (options.timeout || 60) * 60 * 1000;
-  const pollInterval = 5000;
-  const start = Date.now();
-
-  console.log(chalk.cyan(`\n  Waiting for all threads in: ${feature}\n`));
-
-  while (Date.now() - start < timeoutMs) {
-    const threads = listThreads({ feature });
-    const active = threads.filter(t =>
-      t.status === THREAD_STATUS.PENDING || t.status === THREAD_STATUS.RUNNING
-    );
-
-    if (active.length === 0) {
-      const failed = threads.filter(t => t.status === THREAD_STATUS.FAILED);
-      if (failed.length > 0) {
-        console.log(chalk.yellow(`  ⚠ ${failed.length} thread(s) failed`));
-        process.exit(1);
-      }
-      console.log(chalk.green(`  ✓ All ${threads.length} threads completed`));
-      return;
-    }
-
-    process.stdout.write(`\r  Still running: ${active.length} thread(s)...`);
-    await new Promise(r => setTimeout(r, pollInterval));
-  }
-
-  console.error(chalk.red('\n  Timeout waiting for threads'));
-  process.exit(1);
-}
-
-/**
- * Wait for any thread to complete
- */
-export async function threadsWaitAnyCommand(feature, options) {
-  const timeoutMs = (options.timeout || 60) * 60 * 1000;
-  const pollInterval = 3000;
-  const start = Date.now();
-
-  console.log(chalk.cyan(`\n  Waiting for first thread to complete in: ${feature}\n`));
-
-  while (Date.now() - start < timeoutMs) {
-    const threads = listThreads({ feature });
-    const done = threads.find(t =>
-      t.status === THREAD_STATUS.COMPLETED || t.status === THREAD_STATUS.FAILED
-    );
-
-    if (done) {
-      const colorFn = STATUS_COLORS[done.status] || chalk.white;
-      console.log(`  ${colorFn('✓')} Thread ${done.id.substring(0, 8)} ${done.status}`);
-      if (done.agent) console.log(`    Agent: ${done.agent}`);
-      return;
-    }
-
-    await new Promise(r => setTimeout(r, pollInterval));
-  }
-
-  console.error(chalk.red('\n  Timeout waiting for thread'));
-  process.exit(1);
-}