orchestr8 2.7.1 → 3.0.0

package/bin/cli.js

@@ -12,7 +12,28 @@ const {
   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];
@@ -129,6 +150,154 @@ const commands = {
     },
     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: orchestr8 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: orchestr8 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'
@@ -163,6 +332,24 @@ Commands:
   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:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orchestr8",
-  "version": "2.7.1",
+  "version": "3.0.0",
   "description": "Multi-agent workflow framework for automated feature development",
   "main": "src/index.js",
   "bin": {
@@ -20,7 +20,7 @@
   "author": "NewmanJustice",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/NewmanJustice/orchestr8.git"
+    "url": "git+https://github.com/NewmanJustice/agent-workflow.git"
   },
   "license": "MIT",
   "engines": {

package/src/index.js

@@ -50,6 +50,37 @@ const {
   TECHNICAL_KEYWORDS,
   USER_FACING_KEYWORDS
 } = require('./classifier');
+const {
+  parseFlags: parseInteractiveFlags,
+  shouldEnterInteractiveMode,
+  createSession,
+  getSessionProgress,
+  handleCommand,
+  getNextSection,
+  markSectionComplete,
+  markSectionTBD,
+  gatherContext,
+  identifyGaps,
+  generateQuestions,
+  canFinalize,
+  generateSpec,
+  writeSpec,
+  generateHandoff,
+  getOutputPath,
+  SESSION_STATES,
+  SECTION_ORDER,
+  MIN_REQUIRED_SECTIONS,
+  SYSTEM_SPEC_QUESTIONS
+} = require('./interactive');
+const {
+  getDefaultStackConfig,
+  readStackConfig,
+  writeStackConfig,
+  resetStackConfig,
+  setStackConfigValue,
+  detectStackConfig,
+  displayStackConfig
+} = require('./stack');
 const tools = require('./tools');
 
 module.exports = {
@@ -105,6 +136,35 @@ module.exports = {
   logClassification,
   TECHNICAL_KEYWORDS,
   USER_FACING_KEYWORDS,
+  // Stack config exports
+  getDefaultStackConfig,
+  readStackConfig,
+  writeStackConfig,
+  resetStackConfig,
+  setStackConfigValue,
+  detectStackConfig,
+  displayStackConfig,
   // Tools module (model native features)
-  tools
+  tools,
+  // Interactive mode exports
+  parseInteractiveFlags,
+  shouldEnterInteractiveMode,
+  createSession,
+  getSessionProgress,
+  handleCommand,
+  getNextSection,
+  markSectionComplete,
+  markSectionTBD,
+  gatherContext,
+  identifyGaps,
+  generateQuestions,
+  canFinalize,
+  generateSpec,
+  writeSpec,
+  generateHandoff,
+  getOutputPath,
+  SESSION_STATES,
+  SECTION_ORDER,
+  MIN_REQUIRED_SECTIONS,
+  SYSTEM_SPEC_QUESTIONS
 };

package/src/init.js

@@ -2,6 +2,8 @@ const fs = require('fs');
 const path = require('path');
 const readline = require('readline');
 
+const { detectStackConfig, writeStackConfig, CONFIG_FILE: STACK_CONFIG_FILE } = require('./stack');
+
 const PACKAGE_ROOT = path.resolve(__dirname, '..');
 const TARGET_DIR = process.cwd();
 
@@ -41,7 +43,8 @@ function updateGitignore() {
   const entriesToAdd = [
     '# agent-workflow',
     '.claude/implement-queue.json',
-    '.claude/pipeline-history.json'
+    '.claude/pipeline-history.json',
+    '.claude/stack-config.json'
   ];
 
   let content = '';
@@ -109,12 +112,27 @@ async function init() {
   // Update .gitignore
   updateGitignore();
 
+  // Auto-detect tech stack
+  const stackConfigPath = path.join(TARGET_DIR, STACK_CONFIG_FILE);
+  if (!fs.existsSync(stackConfigPath)) {
+    const detected = detectStackConfig(TARGET_DIR);
+    const hasValues = detected.language || detected.runtime;
+    if (hasValues) {
+      writeStackConfig(detected);
+      const parts = [detected.language, detected.runtime, ...detected.frameworks, detected.testRunner].filter(Boolean);
+      console.log(`Detected tech stack: ${parts.join(', ')}`);
+    }
+  } else {
+    console.log('Stack config already exists, skipping detection');
+  }
+
   console.log(`
 orchestr8 initialized successfully!
 
 Next steps:
-1. Add business context documents to .business_context/
-2. Run /implement-feature in Claude Code to start your first feature
+1. Review your tech stack with \`npx orchestr8 stack-config\`
+2. Add business context documents to .business_context/
+3. Run /implement-feature in Claude Code to start your first feature
 `);
 }
 

package/src/interactive.js

@@ -0,0 +1,338 @@
+const fs = require('fs');
+const path = require('path');
+
+const SESSION_STATES = {
+  IDLE: 'idle',
+  GATHERING: 'gathering',
+  QUESTIONING: 'questioning',
+  DRAFTING: 'drafting',
+  FINALIZING: 'finalizing'
+};
+
+const SECTION_ORDER = ['intent', 'scope', 'actors', 'behaviour', 'dependencies'];
+
+const MIN_REQUIRED_SECTIONS = ['intent', 'scope', 'actors'];
+
+const SYSTEM_SPEC_QUESTIONS = ['purpose', 'actors', 'boundaries', 'rules'];
+
+function parseFlags(args) {
+  return {
+    interactive: args.includes('--interactive'),
+    pauseAfter: args.find(a => a.startsWith('--pause-after='))?.split('=')[1] || null
+  };
+}
+
+function shouldEnterInteractiveMode(flags, hasSystemSpec, hasFeatureSpec) {
+  if (flags.interactive) return { interactive: true, target: 'feature' };
+  if (!hasSystemSpec) return { interactive: true, target: 'system' };
+  if (!hasFeatureSpec) return { interactive: true, target: 'feature' };
+  return { interactive: false, target: null };
+}
+
+function createSession(target) {
+  const sections = target === 'system'
+    ? { purpose: null, actors: null, boundaries: null, rules: null }
+    : { intent: null, scope: null, actors: null, behaviour: null, dependencies: null };
+
+  return {
+    target,
+    state: SESSION_STATES.IDLE,
+    sections,
+    current: target === 'system' ? 'purpose' : 'intent',
+    revisionCount: 0,
+    questionCount: 0,
+    startedAt: new Date().toISOString(),
+    aborted: false,
+    specWritten: false,
+    context: {},
+    feedback: []
+  };
+}
+
+function getSessionProgress(session) {
+  const sectionList = Object.keys(session.sections);
+  const complete = Object.values(session.sections).filter(
+    s => s === 'complete' || s === 'TBD'
+  ).length;
+  const remaining = sectionList.length - complete;
+  return { complete, remaining, total: sectionList.length };
+}
+
+function handleCommand(session, command) {
+  const cmd = command.trim().toLowerCase();
+  const parts = command.trim().split(/\s+/);
+  const baseCmd = parts[0].toLowerCase();
+
+  if (baseCmd === '/approve' || baseCmd === 'yes') {
+    session.sections[session.current] = 'complete';
+    const nextSection = getNextSection(session);
+    if (nextSection) {
+      session.current = nextSection;
+      return { action: 'next', section: nextSection };
+    }
+    return { action: 'finalize' };
+  }
+
+  if (baseCmd === '/change') {
+    const feedback = parts.slice(1).join(' ');
+    session.revisionCount++;
+    session.feedback.push({ section: session.current, feedback });
+    return { action: 'revise', feedback };
+  }
+
+  if (baseCmd === '/skip') {
+    session.sections[session.current] = 'TBD';
+    const nextSection = getNextSection(session);
+    if (nextSection) {
+      session.current = nextSection;
+      return { action: 'next', section: nextSection };
+    }
+    return { action: 'finalize' };
+  }
+
+  if (baseCmd === '/restart') {
+    session.sections[session.current] = null;
+    return { action: 'restart', section: session.current };
+  }
+
+  if (baseCmd === '/abort') {
+    session.aborted = true;
+    return { action: 'abort' };
+  }
+
+  if (baseCmd === '/done') {
+    if (canFinalize(session)) {
+      return { action: 'finalize' };
+    }
+    return { action: 'incomplete', missing: getMissingSections(session) };
+  }
+
+  return { action: 'unknown', command: baseCmd };
+}
+
+function getNextSection(session) {
+  const order = session.target === 'system'
+    ? SYSTEM_SPEC_QUESTIONS
+    : SECTION_ORDER;
+
+  for (const section of order) {
+    const status = session.sections[section];
+    if (status !== 'complete' && status !== 'TBD') {
+      return section;
+    }
+  }
+  return null;
+}
+
+function markSectionComplete(session, section) {
+  if (section in session.sections) {
+    session.sections[section] = 'complete';
+    return true;
+  }
+  return false;
+}
+
+function markSectionTBD(session, section) {
+  if (section in session.sections) {
+    session.sections[section] = 'TBD';
+    return true;
+  }
+  return false;
+}
+
+function gatherContext(basePath = '.') {
+  const context = {
+    systemSpec: null,
+    businessContext: [],
+    templates: []
+  };
+
+  const systemSpecPath = path.join(basePath, '.blueprint/system_specification/SYSTEM_SPEC.md');
+  if (fs.existsSync(systemSpecPath)) {
+    context.systemSpec = fs.readFileSync(systemSpecPath, 'utf8');
+  }
+
+  const businessContextDir = path.join(basePath, '.business_context');
+  if (fs.existsSync(businessContextDir)) {
+    const files = fs.readdirSync(businessContextDir);
+    for (const file of files) {
+      if (file.endsWith('.md')) {
+        const content = fs.readFileSync(path.join(businessContextDir, file), 'utf8');
+        context.businessContext.push({ file, content });
+      }
+    }
+  }
+
+  const templatesDir = path.join(basePath, '.blueprint/templates');
+  if (fs.existsSync(templatesDir)) {
+    const files = fs.readdirSync(templatesDir);
+    for (const file of files) {
+      if (file.endsWith('.md')) {
+        const content = fs.readFileSync(path.join(templatesDir, file), 'utf8');
+        context.templates.push({ file, content });
+      }
+    }
+  }
+
+  return context;
+}
+
+function identifyGaps(session, userDescription) {
+  const gaps = [];
+  const sectionKeys = session.target === 'system'
+    ? SYSTEM_SPEC_QUESTIONS
+    : SECTION_ORDER;
+
+  for (const section of sectionKeys) {
+    const hasKey = `has${section.charAt(0).toUpperCase() + section.slice(1)}`;
+    if (!userDescription[hasKey]) {
+      gaps.push(section);
+    }
+  }
+
+  return gaps.slice(0, 4);
+}
+
+function generateQuestions(gaps) {
+  const questionTemplates = {
+    intent: 'What is the primary goal or purpose of this feature?',
+    scope: 'What boundaries define what is in scope vs out of scope?',
+    actors: 'Who are the users or systems that will interact with this?',
+    behaviour: 'What are the key behaviours or flows to support?',
+    dependencies: 'What does this depend on or what depends on it?',
+    purpose: 'What is the overall purpose of this system?',
+    boundaries: 'What are the system boundaries and integration points?',
+    rules: 'What business rules or constraints apply?'
+  };
+
+  return gaps.slice(0, 4).map(gap => ({
+    section: gap,
+    question: questionTemplates[gap] || `What information is needed for ${gap}?`
+  }));
+}
+
+function getMissingSections(session) {
+  const required = session.target === 'system'
+    ? ['purpose', 'actors', 'boundaries']
+    : MIN_REQUIRED_SECTIONS;
+
+  return required.filter(section => {
+    const status = session.sections[section];
+    return status !== 'complete' && status !== 'TBD';
+  });
+}
+
+function canFinalize(session) {
+  const required = session.target === 'system'
+    ? ['purpose', 'actors', 'boundaries']
+    : MIN_REQUIRED_SECTIONS;
+
+  return required.every(section => {
+    const status = session.sections[section];
+    return status === 'complete' || status === 'TBD';
+  });
+}
+
+function generateSpec(session) {
+  const sections = [];
+  const sectionOrder = session.target === 'system'
+    ? SYSTEM_SPEC_QUESTIONS
+    : SECTION_ORDER;
+
+  const title = session.target === 'system' ? 'System Spec' : 'Feature Spec';
+  sections.push(`# ${title}`);
+
+  for (const sectionName of sectionOrder) {
+    const status = session.sections[sectionName];
+    const heading = sectionName.charAt(0).toUpperCase() + sectionName.slice(1);
+    sections.push(`## ${heading}`);
+
+    if (status === 'TBD') {
+      sections.push('TBD');
+    } else if (status === 'complete') {
+      sections.push(`[Content for ${sectionName}]`);
+    } else {
+      sections.push('TBD');
+    }
+  }
+
+  sections.push('');
+  sections.push('_Created via interactive session_');
+
+  return sections.join('\n');
+}
+
+function writeSpec(session, outputPath) {
+  const content = generateSpec(session);
+  const dir = path.dirname(outputPath);
+
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  fs.writeFileSync(outputPath, content);
+  session.specWritten = true;
+  return outputPath;
+}
+
+function generateHandoff(session, slug) {
+  const progress = getSessionProgress(session);
+  const endedAt = new Date().toISOString();
+  const startedAt = new Date(session.startedAt);
+  const durationMs = new Date(endedAt) - startedAt;
+
+  const lines = [
+    '## Handoff Summary',
+    '**For:** Cass',
+    `**Feature:** ${slug}`,
+    '',
+    '### Key Decisions',
+    `- Interactive mode used for ${session.target} spec creation`,
+    `- ${progress.complete}/${progress.total} sections completed`,
+    session.revisionCount > 0 ? `- ${session.revisionCount} revision(s) made` : null,
+    '',
+    '### Files Created',
+    session.target === 'system'
+      ? '- .blueprint/system_specification/SYSTEM_SPEC.md'
+      : `- .blueprint/features/feature_${slug}/FEATURE_SPEC.md`,
+    '',
+    '### Open Questions',
+    progress.remaining > 0 ? `- ${progress.remaining} section(s) marked TBD` : '- None',
+    '',
+    '### Critical Context',
+    `Session duration: ${Math.round(durationMs / 1000)}s, Questions asked: ${session.questionCount}, Revisions: ${session.revisionCount}`
+  ].filter(line => line !== null);
+
+  return lines.join('\n');
+}
+
+function getOutputPath(session, slug, basePath = '.') {
+  if (session.target === 'system') {
+    return path.join(basePath, '.blueprint/system_specification/SYSTEM_SPEC.md');
+  }
+  return path.join(basePath, `.blueprint/features/feature_${slug}/FEATURE_SPEC.md`);
+}
+
+module.exports = {
+  SESSION_STATES,
+  SECTION_ORDER,
+  MIN_REQUIRED_SECTIONS,
+  SYSTEM_SPEC_QUESTIONS,
+  parseFlags,
+  shouldEnterInteractiveMode,
+  createSession,
+  getSessionProgress,
+  handleCommand,
+  getNextSection,
+  markSectionComplete,
+  markSectionTBD,
+  gatherContext,
+  identifyGaps,
+  generateQuestions,
+  getMissingSections,
+  canFinalize,
+  generateSpec,
+  writeSpec,
+  generateHandoff,
+  getOutputPath
+};