@polymorphism-tech/morph-spec 4.2.0 → 4.3.1

package/src/commands/state/state.js

@@ -181,13 +181,13 @@ async function checkpointCommand(featureName, note, options) {
   try {
     const spinner = ora('Creating checkpoint...').start();
 
-    const checkpoint = StateManager.addCheckpoint(featureName, note);
+    const checkpoint = await StateManager.addCheckpoint(featureName, note);
 
     spinner.succeed(`Checkpoint registered for ${chalk.cyan(featureName)}`);
     logger.blank();
-    logger.dim(`  ${checkpoint.note}`);
+    logger.dim(`  ${checkpoint.summary?.note || note}`);
     logger.dim(`  Phase: ${checkpoint.phase}`);
-    logger.dim(`  Tasks completed: ${checkpoint.completedTasks}`);
+    logger.dim(`  Tasks completed: ${checkpoint.summary?.completedTasks ?? 0}`);
     logger.blank();
 
   } catch (error) {
@@ -208,8 +208,10 @@ async function listCommand(options) {
     const features = StateManager.listFeatures();
 
     // Project info
-    logger.info(`Project: ${chalk.cyan(summary.project.name)}`);
-    logger.info(`Type: ${chalk.cyan(summary.project.type)}`);
+    const projectName = summary.project?.name || '(unnamed)';
+    const projectType = summary.project?.type || '(unknown)';
+    logger.info(`Project: ${chalk.cyan(projectName)}`);
+    logger.info(`Type: ${chalk.cyan(projectType)}`);
     logger.blank();
 
     if (features.length === 0) {
@@ -232,21 +234,21 @@ async function listCommand(options) {
         archived: '📦'
       }[feature.status] || '❓';
 
-      const progress = feature.tasks.total > 0
-        ? `${feature.tasks.completed}/${feature.tasks.total}`
+      const tasks = feature.tasks || {};
+      const progress = (tasks.total || 0) > 0
+        ? `${tasks.completed || 0}/${tasks.total}`
         : '0/0';
 
       logger.info(`${statusEmoji}  ${chalk.bold(name)}`);
-      logger.dim(`   Phase: ${feature.phase.padEnd(16)} │ Tasks: ${progress}`);
-      logger.dim(`   Agents: ${feature.activeAgents.slice(0, 5).join(', ') || 'None'}`);
+      logger.dim(`   Phase: ${(feature.phase || 'unknown').padEnd(16)} │ Tasks: ${progress}`);
+      logger.dim(`   Agents: ${(feature.activeAgents || []).slice(0, 5).join(', ') || 'None'}`);
       logger.blank();
     });
 
     // Summary
     logger.header('Summary:');
-    logger.info(`Total Features: ${chalk.cyan(summary.metadata.totalFeatures)}`);
-    logger.info(`Completed: ${chalk.cyan(summary.metadata.completedFeatures)}`);
-    logger.info(`Estimated Cost: ${chalk.cyan(`$${summary.metadata.totalCostEstimated.toFixed(2)}/month`)}`);
+    logger.info(`Total Features: ${chalk.cyan(summary.metadata?.totalFeatures ?? features.length)}`);
+    logger.info(`Completed: ${chalk.cyan(summary.metadata?.completedFeatures ?? 0)}`);
     logger.blank();
 
   } catch (error) {

package/src/commands/tasks/task.js

@@ -9,7 +9,7 @@ import { dirname, join } from 'path';
 import chalk from 'chalk';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const taskManagerPath = join(__dirname, '..', '..', 'bin', 'task-manager.cjs');
+const taskManagerPath = join(__dirname, '..', '..', '..', 'bin', 'task-manager.cjs');
 
 /**
  * Execute task-manager.js with given arguments

package/src/commands/templates/template-render.js

@@ -3,11 +3,90 @@
  */
 
 import { writeFileSync, mkdirSync } from 'fs';
-import { dirname } from 'path';
+import { dirname, join } from 'path';
 import chalk from 'chalk';
 import { logger } from '../../utils/logger.js';
 import { getTemplateById, resolveTemplatePathById } from '../../core/templates/template-registry.js';
 import { renderTemplate } from '../../core/templates/template-renderer.js';
+import { renderHOP, listAvailableHOPs } from '../../lib/hops/hop-composer.js';
+
+/**
+ * Render HOP (Higher-Order Prompt) template command
+ */
+export async function hopRenderCommand(hopId, outputPath, variablesJson, options) {
+  logger.header(`Rendering HOP: ${hopId}`);
+  logger.blank();
+
+  try {
+    // Parse variables
+    let variables = {};
+    try {
+      variables = JSON.parse(variablesJson || '{}');
+    } catch (error) {
+      logger.error('Invalid JSON in variables argument');
+      logger.dim(`  ${error.message}`);
+      process.exit(1);
+    }
+
+    // Add defaults
+    variables.DATE = variables.DATE || new Date().toISOString().split('T')[0];
+    variables.YEAR = variables.YEAR || new Date().getFullYear().toString();
+    variables.TIMESTAMP = variables.TIMESTAMP || new Date().toISOString();
+
+    // Render via hop-composer
+    const frameworkRoot = join(process.cwd(), 'framework');
+    const rendered = renderHOP(hopId, variables, { frameworkRoot });
+
+    if (options?.dryRun || !outputPath) {
+      logger.info(chalk.cyan('📋 HOP Preview:'));
+      logger.blank();
+      console.log(rendered);
+      logger.blank();
+      if (outputPath) logger.dim(`Would be written to: ${outputPath}`);
+    } else {
+      mkdirSync(dirname(outputPath), { recursive: true });
+      writeFileSync(outputPath, rendered, 'utf-8');
+      logger.success(`✅ HOP rendered: ${chalk.cyan(outputPath)}`);
+    }
+  } catch (error) {
+    logger.error(`Failed to render HOP: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * List available HOPs
+ */
+export async function hopListCommand(options) {
+  logger.header('Available HOPs (Higher-Order Prompts)');
+  logger.blank();
+
+  const frameworkRoot = join(process.cwd(), 'framework');
+  const hops = listAvailableHOPs(frameworkRoot);
+
+  if (hops.length === 0) {
+    logger.warn('No HOPs found in framework/templates/meta-prompts/');
+    return;
+  }
+
+  const byType = {};
+  for (const hop of hops) {
+    const type = hop.type || 'other';
+    if (!byType[type]) byType[type] = [];
+    byType[type].push(hop);
+  }
+
+  for (const [type, list] of Object.entries(byType)) {
+    console.log(chalk.cyan(`\n  ${type.toUpperCase()}`));
+    for (const hop of list) {
+      console.log(`    ${chalk.white(hop.id.padEnd(30))} ${chalk.gray(hop.description || hop.path)}`);
+    }
+  }
+
+  logger.blank();
+  logger.dim(`Total: ${hops.length} HOPs`);
+  logger.dim(`Render: morph-spec hop render <hop-id> <output-file> '<variables-json>'`);
+}
 
 /**
  * Render template command

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

@@ -0,0 +1,103 @@
+/**
+ * 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

@@ -0,0 +1,261 @@
+/**
+ * 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);
+}