@girardmedia/bootspring 1.1.0

package/cli/memory.js

@@ -0,0 +1,303 @@
+#!/usr/bin/env node
+
+/**
+ * Bootspring Memory Command
+ * View and manage git-based project memory
+ *
+ * @package bootspring
+ * @command memory
+ */
+
+const path = require('path');
+const gitMemory = require('../intelligence/git-memory');
+const utils = require('../core/utils');
+
+// Colors
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  green: '\x1b[32m',
+  blue: '\x1b[34m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  red: '\x1b[31m',
+  magenta: '\x1b[35m'
+};
+
+/**
+ * Display learnings summary
+ */
+function showSummary(options = {}) {
+  const { limit = 30, since = '3 months ago' } = options;
+
+  console.log(`\n${c.cyan}${c.bold}⚡ Project Memory${c.reset}\n`);
+
+  if (!gitMemory.isGitRepo()) {
+    console.log(`${c.red}Not a git repository${c.reset}`);
+    return;
+  }
+
+  const result = gitMemory.extractLearnings({ limit, since });
+
+  if (result.error) {
+    console.log(`${c.red}Error: ${result.error}${c.reset}`);
+    return;
+  }
+
+  if (result.learnings.length === 0) {
+    console.log(`${c.yellow}No significant learnings found in recent commits${c.reset}`);
+    console.log(`${c.dim}Try using more descriptive commit messages${c.reset}`);
+    return;
+  }
+
+  // Group by category
+  const grouped = gitMemory.groupByCategory(result.learnings);
+
+  console.log(`${c.dim}Extracted ${result.learnings.length} learnings from ${result.total} commits${c.reset}\n`);
+
+  for (const [category, items] of Object.entries(grouped)) {
+    const config = gitMemory.MEMORY_CATEGORIES[category] || { icon: '📝', label: category };
+
+    console.log(`${c.bold}${config.icon} ${config.label}${c.reset} (${items.length})`);
+
+    for (const item of items.slice(0, 3)) {
+      console.log(`  ${c.dim}[${item.hash}]${c.reset} ${item.summary}`);
+    }
+
+    if (items.length > 3) {
+      console.log(`  ${c.dim}... and ${items.length - 3} more${c.reset}`);
+    }
+
+    console.log('');
+  }
+}
+
+/**
+ * Search learnings
+ */
+function searchMemory(query) {
+  console.log(`\n${c.cyan}${c.bold}⚡ Search Memory${c.reset}\n`);
+
+  if (!query) {
+    console.log(`${c.red}Usage: bootspring memory search <query>${c.reset}`);
+    return;
+  }
+
+  const result = gitMemory.extractLearnings({ limit: 100 });
+  const matches = gitMemory.searchLearnings(result.learnings, query);
+
+  console.log(`${c.dim}Found ${matches.length} matches for "${query}"${c.reset}\n`);
+
+  for (const match of matches.slice(0, 15)) {
+    const icons = match.categories
+      .map(cat => gitMemory.MEMORY_CATEGORIES[cat]?.icon || '📝')
+      .join('');
+
+    console.log(`${icons} ${c.bold}${match.summary}${c.reset}`);
+    console.log(`  ${c.dim}[${match.hash}] ${match.date}${c.reset}`);
+
+    if (match.details) {
+      const preview = match.details.split('\n')[0].slice(0, 80);
+      console.log(`  ${c.dim}${preview}${c.reset}`);
+    }
+
+    console.log('');
+  }
+
+  if (matches.length > 15) {
+    console.log(`${c.dim}... and ${matches.length - 15} more matches${c.reset}`);
+  }
+}
+
+/**
+ * Show learnings for specific files
+ */
+function showForFiles(files) {
+  console.log(`\n${c.cyan}${c.bold}⚡ File Memory${c.reset}\n`);
+
+  if (!files || files.length === 0) {
+    console.log(`${c.red}Usage: bootspring memory files <file1> [file2...]${c.reset}`);
+    return;
+  }
+
+  const learnings = gitMemory.getLearningsForFiles(files);
+
+  if (learnings.length === 0) {
+    console.log(`${c.yellow}No learnings found for these files${c.reset}`);
+    return;
+  }
+
+  console.log(`${c.dim}Learnings related to: ${files.join(', ')}${c.reset}\n`);
+
+  for (const learning of learnings) {
+    const icons = learning.categories
+      .map(cat => gitMemory.MEMORY_CATEGORIES[cat]?.icon || '📝')
+      .join('');
+
+    console.log(`${icons} ${c.bold}${learning.summary}${c.reset}`);
+    console.log(`  ${c.dim}[${learning.hash}] File: ${learning.file}${c.reset}`);
+    console.log('');
+  }
+}
+
+/**
+ * Export learnings to markdown
+ */
+function exportMarkdown(outputPath) {
+  const result = gitMemory.extractLearnings({ limit: 50 });
+
+  if (result.error) {
+    console.log(`${c.red}Error: ${result.error}${c.reset}`);
+    return;
+  }
+
+  const markdown = gitMemory.toMarkdown(result.learnings, {
+    title: 'Project Learnings',
+    maxPerCategory: 10
+  });
+
+  if (outputPath) {
+    require('fs').writeFileSync(outputPath, markdown);
+    console.log(`${c.green}Exported to ${outputPath}${c.reset}`);
+  } else {
+    console.log(markdown);
+  }
+}
+
+/**
+ * Show repo stats
+ */
+function showStats() {
+  console.log(`\n${c.cyan}${c.bold}⚡ Repository Stats${c.reset}\n`);
+
+  const stats = gitMemory.getRepoStats();
+
+  if (!stats) {
+    console.log(`${c.red}Not a git repository${c.reset}`);
+    return;
+  }
+
+  console.log(`  ${c.bold}Total Commits:${c.reset}      ${stats.totalCommits}`);
+  console.log(`  ${c.bold}Contributors:${c.reset}       ${stats.contributors}`);
+  console.log(`  ${c.bold}Weekly Activity:${c.reset}    ${stats.weeklyPace} commits`);
+  console.log(`  ${c.bold}First Commit:${c.reset}       ${stats.firstCommit || 'unknown'}`);
+  console.log('');
+
+  // Show category breakdown
+  const result = gitMemory.extractLearnings({ limit: 100 });
+  const grouped = gitMemory.groupByCategory(result.learnings);
+
+  console.log(`${c.bold}Learning Categories:${c.reset}\n`);
+
+  for (const [category, items] of Object.entries(grouped).sort((a, b) => b[1].length - a[1].length)) {
+    const config = gitMemory.MEMORY_CATEGORIES[category] || { icon: '📝', label: category };
+    const bar = '█'.repeat(Math.min(items.length, 20));
+    console.log(`  ${config.icon} ${config.label.padEnd(20)} ${c.cyan}${bar}${c.reset} ${items.length}`);
+  }
+
+  console.log('');
+}
+
+/**
+ * Show help
+ */
+function showHelp() {
+  console.log(`
+${c.bold}Bootspring Memory${c.reset}
+
+Extract and search project learnings from git history.
+
+${c.cyan}Usage:${c.reset}
+  bootspring memory <command> [options]
+
+${c.cyan}Commands:${c.reset}
+  summary              Show categorized learning summary (default)
+  search <query>       Search learnings by keyword
+  files <file...>      Show learnings for specific files
+  export [path]        Export learnings to markdown
+  stats                Show repository statistics
+  categories           List memory categories
+  help                 Show this help
+
+${c.cyan}Options:${c.reset}
+  --limit <n>          Number of commits to analyze (default: 30)
+  --since <date>       How far back to look (default: "3 months ago")
+
+${c.cyan}Examples:${c.reset}
+  bootspring memory summary
+  bootspring memory search "authentication"
+  bootspring memory files src/api/auth.ts
+  bootspring memory export LEARNINGS.md
+  bootspring memory stats
+
+${c.cyan}Categories:${c.reset}
+${Object.entries(gitMemory.MEMORY_CATEGORIES)
+  .map(([key, cfg]) => `  ${cfg.icon} ${key.padEnd(15)} ${cfg.label}`)
+  .join('\n')}
+`);
+}
+
+/**
+ * Main CLI handler
+ */
+async function run(args) {
+  const command = args[0] || 'summary';
+
+  // Parse options
+  const options = {};
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--limit' && args[i + 1]) {
+      options.limit = parseInt(args[i + 1]);
+    }
+    if (args[i] === '--since' && args[i + 1]) {
+      options.since = args[i + 1];
+    }
+  }
+
+  switch (command) {
+    case 'summary':
+    case 'show':
+      showSummary(options);
+      break;
+
+    case 'search':
+      searchMemory(args.slice(1).filter(a => !a.startsWith('--')).join(' '));
+      break;
+
+    case 'files':
+    case 'file':
+      showForFiles(args.slice(1).filter(a => !a.startsWith('--')));
+      break;
+
+    case 'export':
+      exportMarkdown(args[1]);
+      break;
+
+    case 'stats':
+      showStats();
+      break;
+
+    case 'categories':
+      console.log(`\n${c.bold}Memory Categories:${c.reset}\n`);
+      for (const [key, cfg] of Object.entries(gitMemory.MEMORY_CATEGORIES)) {
+        console.log(`  ${cfg.icon} ${key.padEnd(15)} ${c.dim}${cfg.label}${c.reset}`);
+        console.log(`     ${c.dim}Patterns: ${cfg.patterns.slice(0, 3).map(p => p.source).join(', ')}...${c.reset}`);
+      }
+      console.log('');
+      break;
+
+    case 'help':
+    case '--help':
+    case '-h':
+    default:
+      showHelp();
+  }
+}
+
+// CLI execution
+if (require.main === module) {
+  run(process.argv.slice(2));
+}
+
+module.exports = { run };

package/cli/orchestrator.js

@@ -0,0 +1,400 @@
+/**
+ * Bootspring Orchestrator Command
+ * Intelligent agent coordination and workflow management
+ *
+ * @package bootspring
+ * @command orchestrator
+ */
+
+const utils = require('../core/utils');
+const entitlements = require('../core/entitlements');
+const telemetry = require('../core/telemetry');
+const intelligence = require('../intelligence');
+
+function trackTelemetry(event, payload) {
+  try {
+    telemetry.emitEvent(event, payload);
+  } catch {
+    // Do not block CLI flow on telemetry issues.
+  }
+}
+
+/**
+ * Run orchestrator command
+ */
+async function run(args) {
+  const parsedArgs = utils.parseArgs(args);
+  const subcommand = args[0] || 'help';
+  const context = args.slice(1).join(' ');
+  const accessOptions = {
+    mode: parsedArgs['access-mode'],
+    entitled: parsedArgs.entitled,
+    tier: parsedArgs.tier
+  };
+
+  switch (subcommand) {
+    case 'analyze':
+    case 'suggest':
+      runAnalyze(context);
+      break;
+
+    case 'workflow':
+      runWorkflow(args[1], accessOptions);
+      break;
+
+    case 'workflows':
+      runListWorkflows(accessOptions);
+      break;
+
+    case 'start':
+      runStartWorkflow(args[1], accessOptions);
+      break;
+
+    case 'next':
+      runNextStep();
+      break;
+
+    case 'checkpoint':
+      if (!args[1]) {
+        runCheckpoint(undefined, '', accessOptions);
+      } else if (intelligence.getWorkflow(args[1])) {
+        runCheckpoint(args[1], args.slice(2).join(' '), accessOptions);
+      } else {
+        // Convenience: allow `checkpoint <signal>` for active workflow.
+        runCheckpoint(undefined, args.slice(1).join(' '), accessOptions);
+      }
+      break;
+
+    case 'status':
+      runStatus();
+      break;
+
+    case 'agents':
+      runListAgents();
+      break;
+
+    case 'help':
+    default:
+      showHelp();
+  }
+}
+
+/**
+ * Analyze context and suggest agents
+ */
+function runAnalyze(context) {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}Intelligence Analysis${utils.COLORS.reset}
+`);
+
+  const analysis = intelligence.analyzeContext(context);
+
+  console.log(`${utils.COLORS.bold}Current Phase:${utils.COLORS.reset} ${analysis.phase} - ${analysis.phaseConfig?.name || 'Unknown'}`);
+  if (analysis.phaseConfig?.description) {
+    console.log(`${utils.COLORS.dim}${analysis.phaseConfig.description}${utils.COLORS.reset}`);
+  }
+  console.log('');
+
+  if (analysis.suggestions.length === 0) {
+    utils.print.warning('No specific agent suggestions for this context');
+    utils.print.dim('Try providing more context about what you\'re working on');
+    return;
+  }
+
+  console.log(`${utils.COLORS.bold}Suggested Agents:${utils.COLORS.reset}\n`);
+
+  const high = analysis.suggestions.filter(s => s.priority === 'high');
+  const medium = analysis.suggestions.filter(s => s.priority === 'medium');
+
+  if (high.length > 0) {
+    console.log(`  ${utils.COLORS.green}High Priority:${utils.COLORS.reset}`);
+    high.forEach(s => {
+      console.log(`    ${utils.COLORS.green}*${utils.COLORS.reset} ${s.agent}`);
+      console.log(`      ${utils.COLORS.dim}${s.reason}${utils.COLORS.reset}`);
+    });
+    console.log('');
+  }
+
+  if (medium.length > 0) {
+    console.log(`  ${utils.COLORS.yellow}Medium Priority:${utils.COLORS.reset}`);
+    medium.forEach(s => {
+      console.log(`    ${utils.COLORS.yellow}*${utils.COLORS.reset} ${s.agent}`);
+      console.log(`      ${utils.COLORS.dim}${s.reason}${utils.COLORS.reset}`);
+    });
+    console.log('');
+  }
+
+  if (analysis.skills.length > 0) {
+    console.log(`${utils.COLORS.bold}Relevant Skills:${utils.COLORS.reset}`);
+    analysis.skills.forEach(skill => {
+      console.log(`  ${utils.COLORS.cyan}*${utils.COLORS.reset} ${skill}`);
+    });
+    console.log('');
+  }
+
+  utils.print.dim('Invoke an agent: bootspring agent invoke <name>');
+}
+
+/**
+ * Show workflow details
+ */
+function runWorkflow(name, accessOptions = {}) {
+  if (!name) {
+    runListWorkflows(accessOptions);
+    return;
+  }
+
+  const workflow = intelligence.getWorkflow(name);
+
+  if (!workflow) {
+    utils.print.error(`Unknown workflow: ${name}`);
+    const filtered = entitlements.filterAccessibleWorkflows(intelligence.listWorkflows(), accessOptions);
+    console.log('Available: ' + filtered.allowed.map(w => w.key).join(', '));
+    return;
+  }
+
+  const decision = entitlements.checkWorkflowAccess(workflow, accessOptions);
+  if (!decision.allowed) {
+    trackTelemetry('premium_prompted', {
+      capability: 'workflow_pack',
+      workflow: name,
+      tier: workflow.tier || 'free',
+      mode: decision.context?.mode,
+      userTier: decision.context?.tier,
+      reason: decision.code
+    });
+    utils.print.error(decision.reason);
+    return;
+  }
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}Workflow: ${workflow.name}${utils.COLORS.reset}
+
+${utils.COLORS.bold}Description:${utils.COLORS.reset} ${workflow.description}
+${utils.COLORS.bold}Tier:${utils.COLORS.reset} ${workflow.tier || 'free'}
+
+${utils.COLORS.bold}Phases:${utils.COLORS.reset}
+`);
+
+  workflow.phases.forEach((phase, i) => {
+    const isLast = i === workflow.phases.length - 1;
+    const prefix = isLast ? '\\--' : '|--';
+    const line = isLast ? '   ' : '|  ';
+
+    console.log(`  ${prefix} ${utils.COLORS.cyan}${phase.name}${utils.COLORS.reset} ${utils.COLORS.dim}(${phase.duration})${utils.COLORS.reset}`);
+    phase.agents.forEach((agent, j) => {
+      const agentPrefix = j === phase.agents.length - 1 ? '\\-' : '|-';
+      const exists = intelligence.agentExists(agent);
+      const status = exists ? `${utils.COLORS.green}*${utils.COLORS.reset}` : `${utils.COLORS.red}o${utils.COLORS.reset}`;
+      console.log(`  ${line} ${agentPrefix} ${status} ${agent}`);
+    });
+  });
+  if (Array.isArray(workflow.completionSignals) && workflow.completionSignals.length > 0) {
+    console.log(`\n${utils.COLORS.bold}Completion Signals:${utils.COLORS.reset}`);
+    workflow.completionSignals.forEach(signal => {
+      console.log(`  - ${signal}`);
+    });
+  }
+  console.log('');
+}
+
+/**
+ * List all workflows
+ */
+function runListWorkflows(accessOptions = {}) {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}Available Workflows${utils.COLORS.reset}
+`);
+
+  const all = intelligence.listWorkflows();
+  const { allowed, denied } = entitlements.filterAccessibleWorkflows(all, accessOptions);
+
+  allowed.forEach(w => {
+    console.log(`  ${utils.COLORS.cyan}${w.key}${utils.COLORS.reset}`);
+    console.log(`    ${w.description}`);
+    console.log(`    ${utils.COLORS.dim}${w.phaseCount} phases | tier: ${w.tier || 'free'}${utils.COLORS.reset}\n`);
+  });
+  if (denied.length > 0) {
+    console.log(`${utils.COLORS.dim}${denied.length} premium workflow(s) hidden by entitlement policy${utils.COLORS.reset}`);
+  }
+}
+
+/**
+ * Start a workflow
+ */
+function runStartWorkflow(name, accessOptions = {}) {
+  if (!name) {
+    utils.print.error('Usage: bootspring orchestrator start <workflow-name>');
+    return;
+  }
+
+  const workflow = intelligence.getWorkflow(name);
+  if (!workflow) {
+    utils.print.error(`Unknown workflow: ${name}`);
+    return;
+  }
+
+  const decision = entitlements.checkWorkflowAccess(workflow, accessOptions);
+  if (!decision.allowed) {
+    utils.print.error(decision.reason);
+    return;
+  }
+
+  const result = intelligence.startWorkflow(name);
+
+  if (result.success) {
+    utils.print.success(`Started workflow: ${result.workflow}`);
+    console.log(`${utils.COLORS.bold}Current Phase:${utils.COLORS.reset} ${result.currentPhase.name}`);
+    console.log(`${utils.COLORS.bold}Agents:${utils.COLORS.reset} ${result.currentPhase.agents.join(', ')}`);
+  } else {
+    utils.print.error(result.error);
+  }
+}
+
+/**
+ * Advance to next workflow step
+ */
+function runNextStep() {
+  const result = intelligence.advanceWorkflow();
+
+  if (result.success) {
+    if (result.complete) {
+      utils.print.success('Workflow complete!');
+    } else {
+      utils.print.success(`Advanced to step ${result.step}/${result.totalSteps}`);
+      console.log(`${utils.COLORS.bold}Phase:${utils.COLORS.reset} ${result.currentPhase.name}`);
+      console.log(`${utils.COLORS.bold}Agents:${utils.COLORS.reset} ${result.currentPhase.agents.join(', ')}`);
+    }
+  } else {
+    utils.print.error(result.error);
+  }
+}
+
+/**
+ * Show orchestrator status
+ */
+function runStatus() {
+  const state = intelligence.loadState();
+  const currentPhase = intelligence.getCurrentPhase();
+  const phaseConfig = intelligence.PHASE_AGENTS[currentPhase];
+  const agents = intelligence.getAvailableAgents();
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}Orchestrator Status${utils.COLORS.reset}
+
+${utils.COLORS.bold}Current Phase:${utils.COLORS.reset} ${currentPhase} - ${phaseConfig?.name || 'Unknown'}
+${utils.COLORS.bold}Last Analysis:${utils.COLORS.reset} ${state.lastAnalysis || 'Never'}
+${utils.COLORS.bold}Active Workflow:${utils.COLORS.reset} ${state.activeWorkflow || 'None'}
+`);
+
+  if (state.activeWorkflow) {
+    const workflow = intelligence.getWorkflow(state.activeWorkflow);
+    console.log(`${utils.COLORS.bold}Workflow Step:${utils.COLORS.reset} ${state.workflowStep + 1}/${workflow.phases.length}`);
+    const progress = intelligence.getWorkflowSignalProgress(state.activeWorkflow, state);
+    if (progress) {
+      console.log(`${utils.COLORS.bold}Checkpoint Signals:${utils.COLORS.reset} ${progress.completedSignals.length}/${progress.totalSignals}`);
+    }
+  }
+
+  if (state.suggestions.length > 0) {
+    console.log(`${utils.COLORS.bold}Last Suggestions:${utils.COLORS.reset}`);
+    state.suggestions.slice(0, 5).forEach(s => {
+      console.log(`  * ${s.agent} (${s.priority})`);
+    });
+  }
+
+  console.log(`\n${utils.COLORS.bold}Available Agents:${utils.COLORS.reset} ${agents.length}`);
+}
+
+function runCheckpoint(workflowName, signalRef, accessOptions = {}) {
+  const targetWorkflowName = workflowName || intelligence.loadState().activeWorkflow;
+  if (targetWorkflowName) {
+    const workflow = intelligence.getWorkflow(targetWorkflowName);
+    if (workflow) {
+      const decision = entitlements.checkWorkflowAccess(workflow, accessOptions);
+      if (!decision.allowed) {
+        trackTelemetry('premium_prompted', {
+          capability: 'workflow_pack',
+          workflow: targetWorkflowName,
+          tier: workflow.tier || 'free',
+          mode: decision.context?.mode,
+          userTier: decision.context?.tier,
+          reason: decision.code
+        });
+        utils.print.error(decision.reason);
+        return;
+      }
+    }
+  }
+
+  const result = intelligence.markWorkflowCheckpoint(workflowName, signalRef);
+  if (!result.success) {
+    utils.print.error(result.error);
+    if (Array.isArray(result.availableSignals) && result.availableSignals.length > 0) {
+      utils.print.dim(`Available signals: ${result.availableSignals.join(' | ')}`);
+    }
+    return;
+  }
+
+  if (result.alreadyCompleted) {
+    utils.print.warning(`Signal already completed: ${result.signal}`);
+  } else {
+    utils.print.success(`Checkpoint completed: ${result.signal}`);
+  }
+
+  if (result.progress) {
+    console.log(`${utils.COLORS.bold}Progress:${utils.COLORS.reset} ${result.progress.completedSignals.length}/${result.progress.totalSignals}`);
+  }
+}
+
+/**
+ * List available agents
+ */
+function runListAgents() {
+  const agents = intelligence.getAvailableAgents();
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}Available Agents (${agents.length})${utils.COLORS.reset}
+`);
+
+  agents.forEach(agent => {
+    console.log(`  * ${agent}`);
+  });
+  console.log('');
+}
+
+/**
+ * Show help
+ */
+function showHelp() {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}Bootspring Intelligence Orchestrator${utils.COLORS.reset}
+
+${utils.COLORS.bold}Usage:${utils.COLORS.reset}
+  bootspring orchestrator <command> [options]
+
+${utils.COLORS.bold}Commands:${utils.COLORS.reset}
+  analyze [context]   Analyze context and suggest agents
+  suggest [context]   Alias for analyze
+  workflow <name>     Show workflow details
+  workflows           List available workflows
+  start <workflow>    Start a workflow
+  next                Advance to next workflow step
+  checkpoint [w] [s]  Mark workflow completion signal (workflow optional if active)
+  status              Show orchestrator status
+  agents              List available agents
+  help                Show this help
+  --access-mode <m>   Entitlement mode: local (default) or server
+  --entitled <bool>   Entitlement override for premium workflows
+  --tier <tier>       Tier override: free, pro, team, enterprise
+
+${utils.COLORS.bold}Examples:${utils.COLORS.reset}
+  bootspring orchestrator analyze "building authentication api"
+  bootspring orchestrator workflow feature-development
+  bootspring orchestrator start feature-development
+  bootspring orchestrator checkpoint launch-pack 1
+  bootspring orchestrator status
+`);
+}
+
+module.exports = { run };