murmur8 4.2.0 → 4.3.1

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,25 @@
+/**
+ * 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;
+    if (arg === '--cost') flags.cost = 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/cost.js

@@ -0,0 +1,122 @@
+'use strict';
+
+const { createConfigModule } = require('./config-factory');
+
+const DEFAULT_INPUT_PRICE = 3;
+const DEFAULT_OUTPUT_PRICE = 15;
+
+const costConfig = createConfigModule({
+  name: 'Cost',
+  file: '.claude/cost-config.json',
+  defaults: {
+    inputPricePerMillion: DEFAULT_INPUT_PRICE,
+    outputPricePerMillion: DEFAULT_OUTPUT_PRICE
+  },
+  validators: {
+    inputPricePerMillion: (v) => v >= 0 || 'Must be non-negative',
+    outputPricePerMillion: (v) => v >= 0 || 'Must be non-negative'
+  }
+});
+
+function getDefaultPricing() {
+  return {
+    inputPricePerMillion: DEFAULT_INPUT_PRICE,
+    outputPricePerMillion: DEFAULT_OUTPUT_PRICE
+  };
+}
+
+function loadPricingConfig() {
+  return costConfig.read();
+}
+
+function savePricingConfig(config) {
+  costConfig.write(config);
+}
+
+function calculateCost(inputTokens, outputTokens, pricing = getDefaultPricing()) {
+  const inputCost = (inputTokens / 1_000_000) * pricing.inputPricePerMillion;
+  const outputCost = (outputTokens / 1_000_000) * pricing.outputPricePerMillion;
+  return Math.round((inputCost + outputCost) * 1000) / 1000;
+}
+
+function formatCost(cost) {
+  if (cost === null || cost === undefined) return 'N/A';
+  return `$${cost.toFixed(3)}`;
+}
+
+function formatTokens(tokens) {
+  if (tokens === null || tokens === undefined) return 'N/A';
+  return tokens.toLocaleString();
+}
+
+function getCostSummary(stages, pricing = loadPricingConfig()) {
+  const lines = [];
+  let totalInput = 0;
+  let totalOutput = 0;
+  let totalCost = 0;
+
+  for (const [name, data] of Object.entries(stages)) {
+    if (data && data.tokens) {
+      const input = data.tokens.input || 0;
+      const output = data.tokens.output || 0;
+      const cost = data.cost !== undefined ? data.cost : calculateCost(input, output, pricing);
+
+      totalInput += input;
+      totalOutput += output;
+      totalCost += cost;
+
+      lines.push({
+        stage: name,
+        input,
+        output,
+        cost
+      });
+    }
+  }
+
+  return {
+    stages: lines,
+    totals: {
+      input: totalInput,
+      output: totalOutput,
+      cost: totalCost
+    }
+  };
+}
+
+function displayCostSummary(slug, stages) {
+  const summary = getCostSummary(stages);
+
+  console.log(`\nCost Summary for feature: ${slug}\n`);
+  console.log('STAGE            INPUT     OUTPUT    COST');
+
+  for (const s of summary.stages) {
+    const stage = s.stage.padEnd(16);
+    const input = formatTokens(s.input).padStart(9);
+    const output = formatTokens(s.output).padStart(10);
+    const cost = formatCost(s.cost).padStart(8);
+    console.log(`${stage} ${input} ${output}    ${cost}`);
+  }
+
+  console.log('─'.repeat(45));
+  const totalStage = 'TOTAL'.padEnd(16);
+  const totalInput = formatTokens(summary.totals.input).padStart(9);
+  const totalOutput = formatTokens(summary.totals.output).padStart(10);
+  const totalCost = formatCost(summary.totals.cost).padStart(8);
+  console.log(`${totalStage} ${totalInput} ${totalOutput}    ${totalCost}`);
+}
+
+module.exports = {
+  CONFIG_FILE: costConfig.CONFIG_FILE,
+  getDefaultPricing,
+  loadPricingConfig,
+  savePricingConfig,
+  calculateCost,
+  formatCost,
+  formatTokens,
+  getCostSummary,
+  displayCostSummary,
+  displayConfig: costConfig.display,
+  setConfigValue: costConfig.setValue,
+  resetConfig: costConfig.reset
+};