murmur8 4.2.0 → 4.3.0

package/src/commands/murm-config.js

@@ -0,0 +1,52 @@
+/**
+ * murm-config command - View or modify murmuration pipeline configuration
+ */
+const {
+  readMurmConfig,
+  writeMurmConfig,
+  getDefaultMurmConfig
+} = require('../murm');
+
+const description = 'View or modify murmuration pipeline configuration';
+const aliases = ['parallel-config'];
+
+async function run(args) {
+  const subArg = args[1];
+
+  if (subArg === 'set') {
+    const key = args[2];
+    const value = args[3];
+    if (!key || !value) {
+      console.error('Usage: murm-config set <key> <value>');
+      console.error('Valid keys: cli, skill, skillFlags, worktreeDir, maxConcurrency, queueFile');
+      process.exit(1);
+    }
+    const config = readMurmConfig();
+    if (key === 'maxConcurrency') {
+      config[key] = parseInt(value, 10);
+    } else {
+      config[key] = value;
+    }
+    writeMurmConfig(config);
+    console.log(`Set ${key} = ${value}`);
+  } else if (subArg === 'reset') {
+    writeMurmConfig(getDefaultMurmConfig());
+    console.log('Murmuration configuration reset to defaults.');
+  } else {
+    const config = readMurmConfig();
+    console.log('Murmuration Configuration\n');
+    console.log(`  cli:            ${config.cli}`);
+    console.log(`  skill:          ${config.skill}`);
+    console.log(`  skillFlags:     ${config.skillFlags}`);
+    console.log(`  worktreeDir:    ${config.worktreeDir}`);
+    console.log(`  maxConcurrency: ${config.maxConcurrency}`);
+    console.log(`  maxFeatures:    ${config.maxFeatures}`);
+    console.log(`  timeout:        ${config.timeout} min`);
+    console.log(`  minDiskSpaceMB: ${config.minDiskSpaceMB}`);
+    console.log(`  queueFile:      ${config.queueFile}`);
+    console.log('\nTo change: murmur8 murm-config set <key> <value>');
+    console.log('Run pipelines: murmur8 murm <slug1> <slug2> ...');
+  }
+}
+
+module.exports = { run, description, aliases };

package/src/commands/murm.js

@@ -0,0 +1,109 @@
+/**
+ * murm command - Run multiple feature pipelines in parallel using git worktrees
+ */
+const {
+  formatStatus,
+  runMurm,
+  loadQueue,
+  cleanupWorktrees,
+  abortMurm,
+  getLockInfo,
+  getDetailedStatus,
+  formatDetailedStatus,
+  rollbackMurm
+} = require('../murm');
+
+const description = 'Run multiple feature pipelines in parallel using git worktrees';
+const aliases = ['parallel', 'murmuration'];
+
+async function run(args) {
+  const subArg = args[1];
+
+  if (subArg === 'status') {
+    const detailed = args.includes('--detailed') || args.includes('-d');
+    const lock = getLockInfo();
+
+    if (detailed) {
+      const details = getDetailedStatus();
+      console.log(formatDetailedStatus(details));
+    } else {
+      const queue = loadQueue();
+
+      if (!queue.features || queue.features.length === 0) {
+        if (lock) {
+          console.log(`Murmuration execution in progress (PID: ${lock.pid})`);
+          console.log(`Started: ${lock.startedAt}`);
+          console.log(`Features: ${lock.features.join(', ')}`);
+        } else {
+          console.log('No murmuration pipelines active.');
+        }
+        return;
+      }
+
+      console.log('Murmuration Pipeline Status\n');
+      console.log(formatStatus(queue.features));
+      const summary = {
+        running: queue.features.filter(f => f.status === 'murm_running').length,
+        pending: queue.features.filter(f => f.status === 'murm_queued').length,
+        completed: queue.features.filter(f => f.status === 'murm_complete').length,
+        failed: queue.features.filter(f => f.status === 'murm_failed').length,
+        conflicts: queue.features.filter(f => f.status === 'merge_conflict').length
+      };
+      console.log(`\nRunning: ${summary.running} | Pending: ${summary.pending} | Completed: ${summary.completed} | Failed: ${summary.failed} | Conflicts: ${summary.conflicts}`);
+
+      // Show log paths for running/failed
+      const withLogs = queue.features.filter(f =>
+        f.logPath && (f.status === 'murm_running' || f.status === 'murm_failed')
+      );
+      if (withLogs.length > 0) {
+        console.log('\nLog files:');
+        withLogs.forEach(f => console.log(`  ${f.slug}: ${f.logPath}`));
+      }
+
+      console.log('\nTip: Use --detailed for progress bars');
+    }
+  } else if (subArg === 'rollback') {
+    const dryRunFlag = args.includes('--dry-run');
+    const forceFlag = args.includes('--force');
+    await rollbackMurm({ dryRun: dryRunFlag, force: forceFlag });
+  } else if (subArg === 'cleanup') {
+    const cleaned = await cleanupWorktrees();
+    console.log(`Cleaned ${cleaned} worktree(s).`);
+  } else if (subArg === 'abort') {
+    const cleanupFlag = args.includes('--cleanup');
+    await abortMurm({ cleanup: cleanupFlag });
+  } else {
+    const slugs = args.slice(1).filter(a => !a.startsWith('--') && !a.startsWith('-'));
+    if (slugs.length === 0) {
+      console.error('Usage: murmur8 murm <slug1> <slug2> ... [options]');
+      console.error('\nOptions:');
+      console.error('  --dry-run            Preview execution plan without running');
+      console.error('  --yes, -y            Skip confirmation prompt');
+      console.error('  --force              Override existing lock');
+      console.error('  --verbose            Stream output to console (not just logs)');
+      console.error('  --skip-preflight     Skip feature validation checks');
+      console.error('  --max-concurrency=N  Set max parallel pipelines (default: 3)');
+      console.error('\nSubcommands:');
+      console.error('  murm status    Show status of all pipelines');
+      console.error('  murm abort     Stop all running pipelines');
+      console.error('  murm cleanup   Remove completed/aborted worktrees');
+      process.exit(1);
+    }
+
+    const maxFlag = args.find(a => a.startsWith('--max-concurrency='));
+    const options = {
+      dryRun: args.includes('--dry-run'),
+      yes: args.includes('--yes') || args.includes('-y'),
+      force: args.includes('--force'),
+      verbose: args.includes('--verbose'),
+      skipPreflight: args.includes('--skip-preflight')
+    };
+    if (maxFlag) {
+      options.maxConcurrency = parseInt(maxFlag.split('=')[1], 10);
+    }
+    const result = await runMurm(slugs, options);
+    process.exit(result.success ? 0 : 1);
+  }
+}
+
+module.exports = { run, description, aliases };

package/src/commands/queue.js

@@ -0,0 +1,19 @@
+/**
+ * queue command - Show queue status or reset
+ */
+const { displayQueue, resetQueue } = require('../orchestrator');
+
+const description = 'Show queue status (use "reset" to clear)';
+
+async function run(args) {
+  const subArg = args[1];
+
+  if (subArg === 'reset') {
+    resetQueue();
+    console.log('Queue has been reset.');
+  } else {
+    displayQueue();
+  }
+}
+
+module.exports = { run, description };

package/src/commands/retry-config.js

@@ -0,0 +1,28 @@
+/**
+ * retry-config command - Manage retry configuration for adaptive retry logic
+ */
+const { displayConfig, setConfigValue, resetConfig } = require('../retry');
+
+const description = 'Manage retry configuration for adaptive retry logic';
+
+async function run(args) {
+  const subArg = args[1];
+
+  if (subArg === 'set') {
+    const key = args[2];
+    const value = args[3];
+    if (!key || !value) {
+      console.error('Usage: retry-config set <key> <value>');
+      console.error('Valid keys: maxRetries, windowSize, highFailureThreshold');
+      process.exit(1);
+    }
+    setConfigValue(key, value);
+  } else if (subArg === 'reset') {
+    resetConfig();
+    console.log('Retry configuration reset to defaults.');
+  } else {
+    displayConfig();
+  }
+}
+
+module.exports = { run, description };

package/src/commands/stack-config.js

@@ -0,0 +1,32 @@
+/**
+ * stack-config command - View or modify project tech stack configuration
+ */
+const {
+  displayStackConfig,
+  setStackConfigValue,
+  resetStackConfig
+} = require('../stack');
+
+const description = 'View or modify project tech stack configuration';
+
+async function run(args) {
+  const subArg = args[1];
+
+  if (subArg === 'set') {
+    const key = args[2];
+    const value = args[3];
+    if (!key || !value) {
+      console.error('Usage: stack-config set <key> <value>');
+      console.error('Valid keys: language, runtime, packageManager, frameworks, testRunner, testCommand, linter, tools');
+      process.exit(1);
+    }
+    setStackConfigValue(key, value);
+  } else if (subArg === 'reset') {
+    resetStackConfig();
+    console.log('Stack configuration reset to defaults.');
+  } else {
+    displayStackConfig();
+  }
+}
+
+module.exports = { run, description };

package/src/commands/update.js

@@ -0,0 +1,12 @@
+/**
+ * update command - Update agents, templates, and rituals (preserves your content)
+ */
+const { update } = require('../update');
+
+const description = 'Update agents, templates, and rituals (preserves your content)';
+
+async function run(args) {
+  await update();
+}
+
+module.exports = { run, description };

package/src/commands/utils.js

@@ -0,0 +1,24 @@
+/**
+ * Shared utilities for CLI commands
+ */
+
+/**
+ * Parse common flags from command line arguments
+ * @param {string[]} args - Command line arguments
+ * @returns {Object} Parsed flags
+ */
+function parseFlags(args) {
+  const flags = {};
+  for (const arg of args) {
+    if (arg === '--all') flags.all = true;
+    if (arg === '--stats') flags.stats = true;
+    if (arg === '--force') flags.force = true;
+    if (arg === '--bottlenecks') flags.bottlenecks = true;
+    if (arg === '--failures') flags.failures = true;
+    if (arg === '--json') flags.json = true;
+    if (arg === '--feedback') flags.feedback = true;
+  }
+  return flags;
+}
+
+module.exports = { parseFlags };

package/src/commands/validate.js

@@ -0,0 +1,15 @@
+/**
+ * validate command - Run pre-flight checks to validate project configuration
+ */
+const { validate, formatOutput } = require('../validate');
+
+const description = 'Run pre-flight checks to validate project configuration';
+
+async function run(args) {
+  const result = await validate();
+  const useColor = process.stdout.isTTY || false;
+  console.log(formatOutput(result, useColor));
+  process.exit(result.exitCode);
+}
+
+module.exports = { run, description };

package/src/config-factory.js

@@ -0,0 +1,190 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Factory function to create a standardized config module.
+ *
+ * @param {Object} options - Configuration options
+ * @param {string} options.name - Display name for the config (e.g., 'Retry', 'Feedback')
+ * @param {string} options.file - Path to config file (e.g., '.claude/retry-config.json')
+ * @param {Object} options.defaults - Default configuration values
+ * @param {Object} [options.validators] - Map of key -> validator function
+ *   Validator returns true for valid, or error string for invalid
+ * @param {Object} [options.formatters] - Map of key -> display formatter function
+ * @param {string[]} [options.arrayKeys] - Keys that accept JSON array values
+ * @returns {Object} Config module with standard methods
+ */
+function createConfigModule(options) {
+  const {
+    name,
+    file,
+    defaults,
+    validators = {},
+    formatters = {},
+    arrayKeys = []
+  } = options;
+
+  /**
+   * Ensures the config directory exists.
+   */
+  function ensureConfigDir() {
+    const dir = path.dirname(file);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  }
+
+  /**
+   * Returns a copy of the default configuration.
+   */
+  function getDefault() {
+    return JSON.parse(JSON.stringify(defaults));
+  }
+
+  /**
+   * Reads the config from file.
+   * Returns defaults if file is missing or corrupted.
+   * Merges missing keys from defaults.
+   */
+  function read() {
+    ensureConfigDir();
+    if (!fs.existsSync(file)) {
+      return getDefault();
+    }
+    try {
+      const content = fs.readFileSync(file, 'utf8');
+      const parsed = JSON.parse(content);
+      // Merge missing keys from defaults
+      const merged = { ...getDefault(), ...parsed };
+      return merged;
+    } catch (err) {
+      // Graceful degradation: return defaults on parse error
+      return getDefault();
+    }
+  }
+
+  /**
+   * Writes the config to file.
+   * Creates directory if needed.
+   */
+  function write(config) {
+    ensureConfigDir();
+    fs.writeFileSync(file, JSON.stringify(config, null, 2));
+  }
+
+  /**
+   * Resets config to defaults by writing default config to file.
+   */
+  function reset() {
+    write(getDefault());
+  }
+
+  /**
+   * Sets a config value by key.
+   * @param {string} key - Config key
+   * @param {string} value - New value (will be parsed appropriately)
+   */
+  function setValue(key, value) {
+    const validKeys = Object.keys(defaults);
+
+    if (!validKeys.includes(key)) {
+      throw new Error(
+        `Unknown config key: ${key}. Valid keys: ${validKeys.join(', ')}`
+      );
+    }
+
+    let parsed = value;
+
+    // Handle array keys
+    if (arrayKeys.includes(key)) {
+      try {
+        parsed = JSON.parse(value);
+        if (!Array.isArray(parsed)) {
+          throw new Error(`${key} must be a JSON array, e.g. '["a","b"]'`);
+        }
+      } catch (err) {
+        if (err.message.includes('must be a JSON array')) throw err;
+        throw new Error(`${key} must be a valid JSON array, e.g. '["a","b"]'`);
+      }
+    } else {
+      // Type coercion based on default value type
+      const defaultType = typeof defaults[key];
+      if (defaultType === 'number') {
+        parsed = parseFloat(value);
+        if (isNaN(parsed)) {
+          throw new Error(`Invalid value for ${key}: ${value}. Must be a number.`);
+        }
+      } else if (defaultType === 'boolean') {
+        if (value !== 'true' && value !== 'false') {
+          throw new Error(`Invalid value for ${key}: ${value}. Must be true or false.`);
+        }
+        parsed = value === 'true';
+      }
+    }
+
+    // Run custom validator if provided
+    if (validators[key]) {
+      const result = validators[key](parsed);
+      if (result !== true) {
+        throw new Error(`Invalid value for ${key}: ${value}. ${result}`);
+      }
+    }
+
+    const config = read();
+    config[key] = parsed;
+    write(config);
+
+    // Log confirmation
+    const display = Array.isArray(config[key]) ? JSON.stringify(config[key]) : config[key];
+    console.log(`Set ${key} = ${display}`);
+  }
+
+  /**
+   * Displays the current configuration.
+   */
+  function display() {
+    const config = read();
+    console.log(`\n${name} Configuration\n`);
+
+    for (const [key, value] of Object.entries(config)) {
+      let displayValue;
+
+      // Use custom formatter if available
+      if (formatters[key]) {
+        displayValue = formatters[key](value);
+      } else if (Array.isArray(value)) {
+        displayValue = value.length > 0 ? value.join(', ') : '(not set)';
+      } else if (typeof value === 'object' && value !== null) {
+        // For nested objects, format each entry
+        console.log(`\n  ${key}:`);
+        for (const [subKey, subValue] of Object.entries(value)) {
+          const subDisplay = Array.isArray(subValue) ? subValue.join(' -> ') : subValue;
+          console.log(`    ${subKey.padEnd(20)}: ${subDisplay}`);
+        }
+        continue;
+      } else if (value === '' || value === null || value === undefined) {
+        displayValue = '(not set)';
+      } else {
+        displayValue = String(value);
+      }
+
+      console.log(`  ${key.padEnd(20)}: ${displayValue}`);
+    }
+
+    console.log('');
+  }
+
+  return {
+    CONFIG_FILE: file,
+    getDefault,
+    read,
+    write,
+    reset,
+    setValue,
+    display
+  };
+}
+
+module.exports = { createConfigModule };

package/src/feedback.js

@@ -1,5 +1,6 @@
 const fs = require('fs');
 const path = require('path');
+const { colorize } = require('./theme');
 
 const CONFIG_FILE = '.claude/feedback-config.json';
 
@@ -169,10 +170,12 @@ function setConfigValue(key, value) {
  */
 function displayConfig() {
   const config = readConfig();
-  console.log('\nFeedback Configuration\n');
+  const useColor = process.stdout.isTTY;
+
+  console.log('\n' + colorize('Feedback Configuration', 'cyan', useColor) + '\n');
   console.log(`  Min rating threshold:   ${config.minRatingThreshold}`);
   console.log(`  Enabled:                ${config.enabled}`);
-  console.log('\n  Issue Mappings:');
+  console.log('\n  ' + colorize('Issue Mappings:', 'cyan', useColor));
   for (const [issue, strategy] of Object.entries(config.issueMappings)) {
     console.log(`    ${issue.padEnd(24)}: ${strategy}`);
   }

package/src/init.js

@@ -1,26 +1,12 @@
 const fs = require('fs');
 const path = require('path');
-const readline = require('readline');
 
 const { detectStackConfig, writeStackConfig, CONFIG_FILE: STACK_CONFIG_FILE } = require('./stack');
+const { prompt } = require('./utils');
 
 const PACKAGE_ROOT = path.resolve(__dirname, '..');
 const TARGET_DIR = process.cwd();
 
-async function prompt(question) {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-
-  return new Promise((resolve) => {
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve(answer.toLowerCase().trim());
-    });
-  });
-}
-
 function copyDir(src, dest) {
   fs.mkdirSync(dest, { recursive: true });
 

package/src/insights.js

@@ -1,4 +1,5 @@
 const { readHistoryFile, formatDuration } = require('./history');
+const { colorize } = require('./theme');
 
 const STAGES = ['alex', 'cass', 'nigel', 'codey-plan', 'codey-implement'];
 
@@ -229,8 +230,8 @@ function analyzeTrends(history) {
   };
 }
 
-function formatTextOutput(analysis, sections) {
-  const lines = ['\nPipeline Insights\n'];
+function formatTextOutput(analysis, sections, useColor = false) {
+  const lines = ['\n' + colorize('Pipeline Insights', 'cyan', useColor) + '\n'];
 
   const showAll = sections.length === 0;
   const showBottlenecks = showAll || sections.includes('bottlenecks');
@@ -239,24 +240,24 @@ function formatTextOutput(analysis, sections) {
   const showTrends = showAll || sections.includes('trends');
 
   if (showBottlenecks) {
-    lines.push('BOTTLENECK ANALYSIS');
+    lines.push(colorize('BOTTLENECK ANALYSIS', 'cyan', useColor));
     if (analysis.bottlenecks.insufficientData) {
       lines.push(`  ${analysis.bottlenecks.message}`);
     } else {
       lines.push(`  Slowest stage: ${analysis.bottlenecks.bottleneckStage} (${analysis.bottlenecks.percentage}% of pipeline)`);
       lines.push(`  Average duration: ${formatDuration(analysis.bottlenecks.avgDurationMs)}`);
       if (analysis.bottlenecks.isBottleneck) {
-        lines.push('  Status: BOTTLENECK DETECTED');
+        lines.push('  Status: ' + colorize('BOTTLENECK DETECTED', 'yellow', useColor));
       }
       if (analysis.bottlenecks.recommendation) {
-        lines.push(`  Recommendation: ${analysis.bottlenecks.recommendation}`);
+        lines.push(`  Recommendation: ${colorize(analysis.bottlenecks.recommendation, 'yellow', useColor)}`);
       }
     }
     lines.push('');
   }
 
   if (showFailures) {
-    lines.push('FAILURE PATTERNS');
+    lines.push(colorize('FAILURE PATTERNS', 'cyan', useColor));
     if (analysis.failures.noFailures) {
       lines.push(`  ${analysis.failures.message}`);
     } else {
@@ -269,14 +270,14 @@ function formatTextOutput(analysis, sections) {
         }
       }
       if (analysis.failures.recommendation) {
-        lines.push(`  Recommendation: ${analysis.failures.recommendation}`);
+        lines.push(`  Recommendation: ${colorize(analysis.failures.recommendation, 'yellow', useColor)}`);
       }
     }
     lines.push('');
   }
 
   if (showAnomalies) {
-    lines.push('ANOMALY DETECTION');
+    lines.push(colorize('ANOMALY DETECTION', 'cyan', useColor));
     if (analysis.anomalies.insufficientData) {
       lines.push(`  ${analysis.anomalies.message}`);
     } else if (analysis.anomalies.noAnomalies) {
@@ -287,14 +288,14 @@ function formatTextOutput(analysis, sections) {
         lines.push(`    - ${a.slug}/${a.stage}: ${formatDuration(a.actual)} (expected ~${formatDuration(a.expected)}, ${a.deviation}x stddev)`);
       }
       if (analysis.anomalies.recommendation) {
-        lines.push(`  Recommendation: ${analysis.anomalies.recommendation}`);
+        lines.push(`  Recommendation: ${colorize(analysis.anomalies.recommendation, 'yellow', useColor)}`);
       }
     }
     lines.push('');
   }
 
   if (showTrends) {
-    lines.push('TREND ANALYSIS');
+    lines.push(colorize('TREND ANALYSIS', 'cyan', useColor));
     if (analysis.trends.insufficientData) {
       lines.push(`  ${analysis.trends.message}`);
     } else {
@@ -303,7 +304,7 @@ function formatTextOutput(analysis, sections) {
       lines.push(`  Success rate: ${sr.trend} (${sr.change > 0 ? '+' : ''}${sr.change}%)`);
       lines.push(`  Duration: ${dr.trend} (${dr.change > 0 ? '+' : ''}${dr.change}%)`);
       if (analysis.trends.recommendation) {
-        lines.push(`  Recommendation: ${analysis.trends.recommendation}`);
+        lines.push(`  Recommendation: ${colorize(analysis.trends.recommendation, 'yellow', useColor)}`);
       }
     }
     lines.push('');
@@ -334,6 +335,7 @@ function formatJsonOutput(analysis, sections) {
 
 function displayInsights(options = {}) {
   const history = readHistoryFile();
+  const useColor = options.color !== false && process.stdout.isTTY;
 
   if (history.error === 'corrupted') {
     console.log("Warning: History file is corrupted. Run 'murmur8 history clear' to reset.");
@@ -359,7 +361,7 @@ function displayInsights(options = {}) {
   if (options.json) {
     console.log(formatJsonOutput(analysis, sections));
   } else {
-    console.log(formatTextOutput(analysis, sections));
+    console.log(formatTextOutput(analysis, sections, useColor));
   }
 }
 
@@ -437,6 +439,7 @@ function recommendThreshold(history) {
  */
 function displayFeedbackInsights(options = {}) {
   const history = readHistoryFile();
+  const useColor = options.color !== false && process.stdout.isTTY;
 
   if (history.error === 'corrupted') {
     console.log("Warning: History file is corrupted.");
@@ -448,10 +451,10 @@ function displayFeedbackInsights(options = {}) {
     return;
   }
 
-  console.log('\nFeedback Insights\n');
+  console.log('\n' + colorize('Feedback Insights', 'cyan', useColor) + '\n');
 
   // Agent calibration
-  console.log('AGENT CALIBRATION');
+  console.log(colorize('AGENT CALIBRATION', 'cyan', useColor));
   for (const agent of ['alex', 'cass', 'nigel']) {
     const calibration = calculateCalibration(agent, history);
     if (calibration === null) {
@@ -466,7 +469,7 @@ function displayFeedbackInsights(options = {}) {
   // Issue correlations
   const correlations = correlateIssues(history);
   if (Object.keys(correlations).length > 0) {
-    console.log('ISSUE CORRELATIONS');
+    console.log(colorize('ISSUE CORRELATIONS', 'cyan', useColor));
     const sorted = Object.entries(correlations)
       .sort(([, a], [, b]) => b - a);
     for (const [issue, corr] of sorted) {
@@ -482,7 +485,7 @@ function displayFeedbackInsights(options = {}) {
   );
   if (entriesWithFeedback.length >= 10) {
     const recommended = recommendThreshold(history);
-    console.log('RECOMMENDATIONS');
+    console.log(colorize('RECOMMENDATIONS', 'cyan', useColor));
     console.log(`  Suggested minRatingThreshold: ${recommended}`);
     console.log('');
   }