murmur8 4.1.1 → 4.3.0

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/history.js

@@ -100,6 +100,96 @@ function formatDuration(ms) {
   return `${minutes}m ${secs}s`;
 }
 
+function isValidDateFormat(dateStr) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(dateStr)) return false;
+  const date = new Date(dateStr);
+  return !isNaN(date.getTime());
+}
+
+function escapeCSVField(value) {
+  if (value === null || value === undefined) return '';
+  const str = String(value);
+  if (str.includes(',') || str.includes('"') || str.includes('\n')) {
+    return `"${str.replace(/"/g, '""')}"`;
+  }
+  return str;
+}
+
+function formatCSV(entries) {
+  const headers = ['slug', 'status', 'startedAt', 'completedAt', 'totalDurationMs', 'failedStage', 'pausedAfter'];
+  const lines = [headers.join(',')];
+  for (const entry of entries) {
+    const row = headers.map(h => escapeCSVField(entry[h]));
+    lines.push(row.join(','));
+  }
+  return lines.join('\n');
+}
+
+function formatJSON(entries) {
+  return JSON.stringify(entries, null, 2);
+}
+
+async function exportHistory(options = {}) {
+  const { format = 'csv', since, until, status, feature, output } = options;
+
+  const history = readHistoryFile();
+
+  if (history.error === 'corrupted') {
+    return { exitCode: 1, error: "History file is corrupted. Run 'murmur8 history clear' to reset." };
+  }
+
+  if (since && !isValidDateFormat(since)) {
+    return { exitCode: 1, error: 'Invalid --since format. Use YYYY-MM-DD.' };
+  }
+
+  if (until && !isValidDateFormat(until)) {
+    return { exitCode: 1, error: 'Invalid --until format. Use YYYY-MM-DD.' };
+  }
+
+  const validStatuses = ['success', 'failed', 'paused'];
+  if (status && !validStatuses.includes(status)) {
+    return { exitCode: 1, error: `Invalid --status value. Use: success, failed, paused.` };
+  }
+
+  let filtered = history;
+
+  if (since) {
+    const sinceDate = new Date(since);
+    filtered = filtered.filter(e => e.completedAt && new Date(e.completedAt) >= sinceDate);
+  }
+
+  if (until) {
+    const untilDate = new Date(until);
+    untilDate.setDate(untilDate.getDate() + 1);
+    filtered = filtered.filter(e => e.completedAt && new Date(e.completedAt) < untilDate);
+  }
+
+  if (status) {
+    filtered = filtered.filter(e => e.status === status);
+  }
+
+  if (feature) {
+    filtered = filtered.filter(e => e.slug === feature);
+  }
+
+  const formatted = format === 'json' ? formatJSON(filtered) : formatCSV(filtered);
+
+  if (output) {
+    try {
+      const dir = path.dirname(output);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(output, formatted);
+      return { message: `Exported ${filtered.length} entries to ${output}` };
+    } catch (err) {
+      return { exitCode: 1, error: err.message };
+    }
+  }
+
+  return { output: formatted };
+}
+
 function formatDate(isoString) {
   const date = new Date(isoString);
   return date.toISOString().replace('T', ' ').slice(0, 19);
@@ -292,5 +382,6 @@ module.exports = {
   displayHistory,
   showStats,
   clearHistory,
-  formatDuration
+  formatDuration,
+  exportHistory
 };

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 });