murmur8 3.5.0

package/bin/cli.js

@@ -0,0 +1,388 @@
+#!/usr/bin/env node
+
+const { init } = require('../src/init');
+const { update } = require('../src/update');
+const { displayQueue, resetQueue } = require('../src/orchestrator');
+const { validate, formatOutput } = require('../src/validate');
+const { displayHistory, showStats, clearHistory } = require('../src/history');
+const { displayInsights } = require('../src/insights');
+const { displayConfig, setConfigValue, resetConfig } = require('../src/retry');
+const {
+  displayConfig: displayFeedbackConfig,
+  setConfigValue: setFeedbackConfigValue,
+  resetConfig: resetFeedbackConfig
+} = require('../src/feedback');
+const {
+  displayStackConfig,
+  setStackConfigValue,
+  resetStackConfig
+} = require('../src/stack');
+const { displayFeedbackInsights } = require('../src/insights');
+const {
+  formatStatus,
+  getDefaultConfig,
+  splitByLimit,
+  runParallel,
+  loadQueue,
+  cleanupWorktrees,
+  readParallelConfig,
+  writeParallelConfig,
+  getDefaultParallelConfig,
+  abortParallel,
+  getLockInfo,
+  getDetailedStatus,
+  formatDetailedStatus,
+  rollbackParallel
+} = require('../src/parallel');
+
+const args = process.argv.slice(2);
+const command = args[0];
+const subArg = args[1];
+
+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;
+}
+
+const commands = {
+  init: {
+    fn: init,
+    description: 'Initialize .blueprint directory in current project'
+  },
+  update: {
+    fn: update,
+    description: 'Update agents, templates, and rituals (preserves your content)'
+  },
+  queue: {
+    fn: () => {
+      if (subArg === 'reset') {
+        resetQueue();
+        console.log('Queue has been reset.');
+      } else {
+        displayQueue();
+      }
+    },
+    description: 'Show queue status (use "reset" to clear)'
+  },
+  validate: {
+    fn: async () => {
+      const result = await validate();
+      const useColor = process.stdout.isTTY || false;
+      console.log(formatOutput(result, useColor));
+      process.exit(result.exitCode);
+    },
+    description: 'Run pre-flight checks to validate project configuration'
+  },
+  history: {
+    fn: async () => {
+      const flags = parseFlags(args);
+      if (subArg === 'clear') {
+        await clearHistory({ force: flags.force });
+      } else if (flags.stats) {
+        showStats();
+      } else {
+        displayHistory({ all: flags.all });
+      }
+    },
+    description: 'View pipeline execution history'
+  },
+  insights: {
+    fn: () => {
+      const flags = parseFlags(args);
+      if (flags.feedback) {
+        displayFeedbackInsights({ json: flags.json });
+      } else {
+        displayInsights({
+          bottlenecks: flags.bottlenecks,
+          failures: flags.failures,
+          json: flags.json
+        });
+      }
+    },
+    description: 'Analyze pipeline history for bottlenecks, failures, and trends'
+  },
+  'retry-config': {
+    fn: () => {
+      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();
+      }
+    },
+    description: 'Manage retry configuration for adaptive retry logic'
+  },
+  'feedback-config': {
+    fn: () => {
+      if (subArg === 'set') {
+        const key = args[2];
+        const value = args[3];
+        if (!key || !value) {
+          console.error('Usage: feedback-config set <key> <value>');
+          console.error('Valid keys: minRatingThreshold, enabled');
+          process.exit(1);
+        }
+        setFeedbackConfigValue(key, value);
+      } else if (subArg === 'reset') {
+        resetFeedbackConfig();
+        console.log('Feedback configuration reset to defaults.');
+      } else {
+        displayFeedbackConfig();
+      }
+    },
+    description: 'Manage feedback loop configuration'
+  },
+  'stack-config': {
+    fn: () => {
+      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();
+      }
+    },
+    description: 'View or modify project tech stack configuration'
+  },
+  'parallel-config': {
+    fn: () => {
+      if (subArg === 'set') {
+        const key = args[2];
+        const value = args[3];
+        if (!key || !value) {
+          console.error('Usage: parallel-config set <key> <value>');
+          console.error('Valid keys: cli, skill, skillFlags, worktreeDir, maxConcurrency, queueFile');
+          process.exit(1);
+        }
+        const config = readParallelConfig();
+        if (key === 'maxConcurrency') {
+          config[key] = parseInt(value, 10);
+        } else {
+          config[key] = value;
+        }
+        writeParallelConfig(config);
+        console.log(`Set ${key} = ${value}`);
+      } else if (subArg === 'reset') {
+        writeParallelConfig(getDefaultParallelConfig());
+        console.log('Parallel configuration reset to defaults.');
+      } else {
+        const config = readParallelConfig();
+        console.log('Parallel 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 parallel-config set <key> <value>');
+      }
+    },
+    description: 'View or modify parallel pipeline configuration'
+  },
+  parallel: {
+    fn: async () => {
+      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(`Parallel execution in progress (PID: ${lock.pid})`);
+              console.log(`Started: ${lock.startedAt}`);
+              console.log(`Features: ${lock.features.join(', ')}`);
+            } else {
+              console.log('No parallel pipelines active.');
+            }
+            return;
+          }
+
+          console.log('Parallel Pipeline Status\n');
+          console.log(formatStatus(queue.features));
+          const summary = {
+            running: queue.features.filter(f => f.status === 'parallel_running').length,
+            pending: queue.features.filter(f => f.status === 'parallel_queued').length,
+            completed: queue.features.filter(f => f.status === 'parallel_complete').length,
+            failed: queue.features.filter(f => f.status === 'parallel_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 === 'parallel_running' || f.status === 'parallel_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 rollbackParallel({ 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 abortParallel({ cleanup: cleanupFlag });
+      } else {
+        const slugs = args.slice(1).filter(a => !a.startsWith('--') && !a.startsWith('-'));
+        if (slugs.length === 0) {
+          console.error('Usage: murmur8 parallel <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('  parallel status    Show status of all pipelines');
+          console.error('  parallel abort     Stop all running pipelines');
+          console.error('  parallel 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 runParallel(slugs, options);
+        process.exit(result.success ? 0 : 1);
+      }
+    },
+    description: 'Run multiple feature pipelines in parallel using git worktrees'
+  },
+  help: {
+    fn: showHelp,
+    description: 'Show this help message'
+  }
+};
+
+function showHelp() {
+  console.log(`
+murmur8 - Multi-agent workflow framework
+
+Usage: murmur8 <command> [options]
+
+Commands:
+  init                  Initialize .blueprint directory in current project
+  update                Update agents, templates, and rituals (preserves your content)
+  validate              Run pre-flight checks to validate project configuration
+  queue                 Show current queue state for /implement-feature pipeline
+  queue reset           Clear the queue and reset all state
+  history               View recent pipeline runs (last 10 by default)
+  history --all         View all pipeline runs
+  history --stats       View aggregate statistics
+  history clear         Clear all pipeline history (with confirmation)
+  history clear --force Clear all pipeline history (no confirmation)
+  insights              Analyze pipeline for bottlenecks, failures, and trends
+  insights --bottlenecks Show only bottleneck analysis
+  insights --failures   Show only failure patterns
+  insights --feedback   Show feedback loop insights (calibration, correlations)
+  insights --json       Output analysis as JSON
+  retry-config          View current retry configuration
+  retry-config set <key> <value>  Modify a config value (maxRetries, windowSize, highFailureThreshold)
+  retry-config reset    Reset retry configuration to defaults
+  feedback-config       View current feedback loop configuration
+  feedback-config set <key> <value>  Modify a config value (minRatingThreshold, enabled)
+  feedback-config reset Reset feedback configuration to defaults
+  stack-config          View current tech stack configuration
+  stack-config set <key> <value>  Modify a config value (language, runtime, frameworks, etc.)
+  stack-config reset    Reset tech stack configuration to defaults
+  parallel <slugs...>   Run multiple feature pipelines in parallel
+  parallel <slugs...> --dry-run  Show execution plan without running
+  parallel <slugs...> --yes      Skip confirmation prompt
+  parallel <slugs...> --verbose  Stream output to console
+  parallel <slugs...> --skip-preflight  Skip feature validation checks
+  parallel status       Show status of all parallel pipelines
+  parallel status --detailed  Show progress bars and stage info
+  parallel abort        Stop all running pipelines
+  parallel abort --cleanup  Stop all and remove worktrees
+  parallel rollback     Undo completed merges and cleanup failures
+  parallel rollback --dry-run  Preview what would be rolled back
+  parallel cleanup      Remove completed/aborted worktrees
+  parallel-config       View parallel pipeline configuration
+  parallel-config set <key> <value>  Modify config (cli, skill, skillFlags, etc.)
+  parallel-config reset Reset parallel configuration to defaults
+  help                  Show this help message
+
+Examples:
+  npx murmur8 init
+  npx murmur8 update
+  npx murmur8 validate
+  npx murmur8 queue
+  npx murmur8 history
+  npx murmur8 history --stats
+  npx murmur8 insights --feedback
+  npx murmur8 feedback-config
+`);
+}
+
+async function main() {
+  if (!command || command === 'help' || command === '--help' || command === '-h') {
+    showHelp();
+    process.exit(0);
+  }
+
+  const cmd = commands[command];
+  if (!cmd) {
+    console.error(`Unknown command: ${command}`);
+    console.error('Run "agent-workflow help" for usage information.');
+    process.exit(1);
+  }
+
+  try {
+    await cmd.fn();
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+main();

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "murmur8",
+  "version": "3.5.0",
+  "description": "Multi-agent workflow framework for automated feature development",
+  "main": "src/index.js",
+  "bin": {
+    "murmur8": "bin/cli.js"
+  },
+  "scripts": {
+    "test": "node --test"
+  },
+  "keywords": [
+    "agent",
+    "workflow",
+    "ai",
+    "automation",
+    "claude",
+    "feature-development"
+  ],
+  "author": "NewmanJustice",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NewmanJustice/agent-workflow.git"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "bin",
+    "src",
+    ".blueprint",
+    ".business_context",
+    "SKILL.md"
+  ]
+}

package/src/business-context.js

@@ -0,0 +1,91 @@
+/**
+ * Business context detection and conditional inclusion module.
+ *
+ * Implements lazy loading of business context by detecting references
+ * in feature specs and conditionally including the context directive
+ * based on agent name and detection results.
+ */
+
+/**
+ * Detects if a feature spec content references business context.
+ * Matches '.business_context' or 'business_context/' patterns.
+ *
+ * @param {string} featureSpecContent - The content of the feature spec
+ * @returns {boolean} True if business context references are found
+ */
+function needsBusinessContext(featureSpecContent) {
+  return featureSpecContent.includes('.business_context')
+    || featureSpecContent.includes('business_context/');
+}
+
+/**
+ * Parses command arguments for the --include-business-context flag.
+ *
+ * @param {string[]} args - Array of command line arguments
+ * @returns {boolean} True if the flag is present
+ */
+function parseIncludeBusinessContextFlag(args) {
+  return args.includes('--include-business-context');
+}
+
+/**
+ * Determines if an agent should receive business context.
+ * Alex always gets business context (exception).
+ * Override flag forces inclusion for all agents.
+ * Otherwise, uses detection result.
+ *
+ * @param {string} agentName - Name of the agent (alex, cass, nigel, codey)
+ * @param {boolean} detected - Whether business context was detected in spec
+ * @param {boolean} overrideFlag - Whether --include-business-context flag is set
+ * @returns {boolean} True if agent should receive business context
+ */
+function shouldIncludeBusinessContext(agentName, detected, overrideFlag) {
+  // Alex always gets business context
+  if (agentName.toLowerCase() === 'alex') {
+    return true;
+  }
+  // Override flag forces inclusion
+  if (overrideFlag) {
+    return true;
+  }
+  // Otherwise use detection result
+  return detected;
+}
+
+/**
+ * Builds queue state object with business context detection result.
+ *
+ * @param {string} featureSlug - The feature slug identifier
+ * @param {boolean} needsContext - Whether business context is needed
+ * @returns {object} Queue state object
+ */
+function buildQueueState(featureSlug, needsContext) {
+  return {
+    feature: featureSlug,
+    current: {
+      stage: 'pending',
+      needsBusinessContext: needsContext
+    }
+  };
+}
+
+/**
+ * Generates the business context directive for agent prompts.
+ *
+ * @param {boolean} includeContext - Whether to include the directive
+ * @returns {string} The directive string or empty string
+ */
+function generateBusinessContextDirective(includeContext) {
+  if (includeContext) {
+    return 'Business Context: .business_context/';
+  }
+  return '';
+}
+
+module.exports = {
+  needsBusinessContext,
+  parseIncludeBusinessContextFlag,
+  shouldIncludeBusinessContext,
+  buildQueueState,
+  generateBusinessContextDirective
+};

package/src/classifier.js

@@ -0,0 +1,173 @@
+/**
+ * Smart Story Routing - Feature Classifier Module
+ *
+ * Classifies features as "technical" or "user-facing" to determine
+ * whether the Cass (story writing) stage should be included in the pipeline.
+ */
+
+// Technical keywords indicate infrastructure/internal work
+const TECHNICAL_KEYWORDS = [
+  'refactor',
+  'token',
+  'performance',
+  'module',
+  'internal',
+  'infrastructure',
+  'optimization',
+  'extract',
+  'compress',
+  'cache',
+  'schema',
+  'validation',
+  'helper',
+  'utility',
+  'config'
+];
+
+// User-facing keywords indicate customer-visible features
+const USER_FACING_KEYWORDS = [
+  'user',
+  'customer',
+  'ui',
+  'screen',
+  'journey',
+  'flow',
+  'experience',
+  'interface',
+  'form',
+  'button',
+  'login',
+  'signup',
+  'dashboard',
+  'notification',
+  'email'
+];
+
+/**
+ * Classify a feature specification as technical or user-facing
+ * @param {string} content - The feature specification content
+ * @returns {Object} Classification result with type, counts, and reason
+ */
+function classifyFeature(content) {
+  const lowerContent = (content || '').toLowerCase();
+
+  let technicalCount = 0;
+  let userFacingCount = 0;
+  const technicalMatches = [];
+  const userFacingMatches = [];
+
+  // Count technical keyword matches
+  for (const keyword of TECHNICAL_KEYWORDS) {
+    const regex = new RegExp(`\\b${keyword}\\b`, 'gi');
+    const matches = lowerContent.match(regex);
+    if (matches) {
+      technicalCount += matches.length;
+      technicalMatches.push(keyword);
+    }
+  }
+
+  // Count user-facing keyword matches
+  for (const keyword of USER_FACING_KEYWORDS) {
+    const regex = new RegExp(`\\b${keyword}\\b`, 'gi');
+    const matches = lowerContent.match(regex);
+    if (matches) {
+      userFacingCount += matches.length;
+      userFacingMatches.push(keyword);
+    }
+  }
+
+  // Determine type - tie goes to user-facing (conservative default)
+  const type = technicalCount > userFacingCount ? 'technical' : 'user-facing';
+
+  // Build reason string
+  let reason;
+  if (technicalCount === 0 && userFacingCount === 0) {
+    reason = 'No keywords found, defaulting to user-facing';
+  } else if (technicalCount > userFacingCount) {
+    reason = `Technical keywords (${technicalMatches.join(', ')}) outweigh user-facing`;
+  } else if (userFacingCount > technicalCount) {
+    reason = `User-facing keywords (${userFacingMatches.join(', ')}) outweigh technical`;
+  } else {
+    reason = 'Tie between technical and user-facing, defaulting to user-facing';
+  }
+
+  return {
+    type,
+    technicalCount,
+    userFacingCount,
+    reason
+  };
+}
+
+/**
+ * Parse story-related flags from command arguments
+ * @param {string[]} args - Array of command arguments
+ * @returns {Object} Parsed flags with override value
+ */
+function parseStoryFlags(args) {
+  const argList = args || [];
+
+  if (argList.includes('--with-stories')) {
+    return { override: 'include' };
+  }
+
+  if (argList.includes('--skip-stories')) {
+    return { override: 'skip' };
+  }
+
+  return { override: null };
+}
+
+/**
+ * Determine whether stories should be included in the pipeline
+ * @param {string} featureType - 'technical' or 'user-facing'
+ * @param {string|null} override - 'include', 'skip', or null
+ * @returns {boolean} Whether to include stories in the pipeline
+ */
+function shouldIncludeStories(featureType, override) {
+  // Override takes precedence
+  if (override === 'include') {
+    return true;
+  }
+  if (override === 'skip') {
+    return false;
+  }
+
+  // Default behavior based on classification
+  return featureType === 'user-facing';
+}
+
+/**
+ * Build queue state object with classification data
+ * @param {string} slug - Feature slug
+ * @param {string} featureType - 'technical' or 'user-facing'
+ * @param {boolean} includeStories - Whether stories are included
+ * @returns {Object} Queue state object with featureType and skippedCass fields
+ */
+function buildClassifiedQueueState(slug, featureType, includeStories) {
+  return {
+    slug,
+    featureType,
+    skippedCass: !includeStories
+  };
+}
+
+/**
+ * Log classification result to console
+ * @param {Object} result - Classification result from classifyFeature
+ */
+function logClassification(result) {
+  console.log(`Feature classified as ${result.type}: ${result.reason}`);
+  console.log(`  Technical indicators: ${result.technicalCount}`);
+  console.log(`  User-facing indicators: ${result.userFacingCount}`);
+}
+
+module.exports = {
+  TECHNICAL_KEYWORDS,
+  USER_FACING_KEYWORDS,
+  classifyFeature,
+  parseStoryFlags,
+  shouldIncludeStories,
+  buildClassifiedQueueState,
+  logClassification
+};