@girardmedia/bootspring 1.1.0

package/intelligence/git-memory.js

@@ -0,0 +1,551 @@
+#!/usr/bin/env node
+
+/**
+ * Bootspring Git Memory
+ *
+ * Extracts learnings, patterns, and decisions from git history.
+ * Replaces Ralph's progress.txt with structured git-based memory.
+ *
+ * @package bootspring
+ * @module intelligence/git-memory
+ */
+
+const { execSync } = require('child_process');
+const path = require('path');
+
+/**
+ * Memory categories extracted from commits
+ */
+const MEMORY_CATEGORIES = {
+  DECISION: {
+    patterns: [
+      /decided to/i, /chose to/i, /switched to/i, /migrated to/i,
+      /now using/i, /replaced .+ with/i, /prefer/i
+    ],
+    icon: '🎯',
+    label: 'Decisions'
+  },
+  BUGFIX: {
+    patterns: [
+      /fix(ed|es)?:/i, /bug(fix)?:/i, /resolved/i, /patched/i,
+      /was causing/i, /issue with/i, /broke/i, /fixed by/i
+    ],
+    icon: '🐛',
+    label: 'Bug Fixes & Gotchas'
+  },
+  PATTERN: {
+    patterns: [
+      /pattern/i, /refactor/i, /abstracted/i, /extracted/i,
+      /standardized/i, /convention/i, /approach/i
+    ],
+    icon: '🔧',
+    label: 'Patterns & Conventions'
+  },
+  ARCHITECTURE: {
+    patterns: [
+      /architect/i, /structure/i, /reorganiz/i, /module/i,
+      /split/i, /merged/i, /moved .+ to/i, /renamed/i
+    ],
+    icon: '🏗️',
+    label: 'Architecture'
+  },
+  DEPENDENCY: {
+    patterns: [
+      /added .+ dependency/i, /upgraded/i, /downgraded/i,
+      /pinned/i, /removed .+ package/i, /npm/i, /yarn/i
+    ],
+    icon: '📦',
+    label: 'Dependencies'
+  },
+  PERFORMANCE: {
+    patterns: [
+      /performance/i, /optimiz/i, /faster/i, /slower/i,
+      /memory/i, /cache/i, /lazy/i, /async/i
+    ],
+    icon: '⚡',
+    label: 'Performance'
+  },
+  SECURITY: {
+    patterns: [
+      /security/i, /vulnerab/i, /auth/i, /permission/i,
+      /sanitiz/i, /validat/i, /escape/i, /inject/i
+    ],
+    icon: '🔒',
+    label: 'Security'
+  },
+  CONFIG: {
+    patterns: [
+      /config/i, /environment/i, /\.env/i, /settings/i,
+      /setup/i, /initialize/i
+    ],
+    icon: '⚙️',
+    label: 'Configuration'
+  }
+};
+
+/**
+ * Execute git command and return output
+ */
+function git(command, options = {}) {
+  try {
+    const cwd = options.cwd || process.cwd();
+    return execSync(`git ${command}`, {
+      cwd,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe']
+    }).trim();
+  } catch (e) {
+    if (options.throwOnError) throw e;
+    return '';
+  }
+}
+
+/**
+ * Check if current directory is a git repo
+ */
+function isGitRepo(cwd = process.cwd()) {
+  try {
+    git('rev-parse --git-dir', { cwd, throwOnError: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get recent commits with full messages
+ */
+function getCommits(options = {}) {
+  const {
+    limit = 100,
+    since = null,
+    until = null,
+    author = null,
+    path: filePath = null,
+    cwd = process.cwd()
+  } = options;
+
+  // Use %x00 (null char) as record separator and ||| as field separator
+  // This handles multi-line commit bodies correctly
+  let command = `log --pretty=format:"%H|||%ai|||%an|||%s%x00" -n ${limit}`;
+
+  if (since) command += ` --since="${since}"`;
+  if (until) command += ` --until="${until}"`;
+  if (author) command += ` --author="${author}"`;
+  if (filePath) command += ` -- "${filePath}"`;
+
+  const output = git(command, { cwd });
+  if (!output) return [];
+
+  // Split by null character to get individual commits
+  return output.split('\x00')
+    .filter(record => record.trim())
+    .map(record => {
+      const [hash, date, author, subject] = record.trim().split('|||');
+      return {
+        hash: hash?.slice(0, 8),
+        date,
+        author,
+        subject,
+        body: '', // Body extraction removed for simplicity - subject is enough for categorization
+        fullMessage: subject || ''
+      };
+    })
+    .filter(c => c.hash && c.hash.length === 8);
+}
+
+/**
+ * Categorize a commit based on its message
+ */
+function categorizeCommit(commit) {
+  const message = commit.fullMessage.toLowerCase();
+  const categories = [];
+
+  for (const [category, config] of Object.entries(MEMORY_CATEGORIES)) {
+    for (const pattern of config.patterns) {
+      if (pattern.test(commit.fullMessage)) {
+        categories.push(category);
+        break;
+      }
+    }
+  }
+
+  // Default to general if no category matched
+  if (categories.length === 0) {
+    categories.push('GENERAL');
+  }
+
+  return categories;
+}
+
+/**
+ * Extract files changed in a commit
+ */
+function getCommitFiles(hash, cwd = process.cwd()) {
+  const output = git(`show --name-only --pretty=format:"" ${hash}`, { cwd });
+  return output.split('\n').filter(f => f.trim());
+}
+
+/**
+ * Extract learnings from commit history
+ */
+function extractLearnings(options = {}) {
+  const {
+    limit = 50,
+    since = '3 months ago',
+    cwd = process.cwd(),
+    includeFiles = false
+  } = options;
+
+  if (!isGitRepo(cwd)) {
+    return { error: 'Not a git repository', learnings: [] };
+  }
+
+  const commits = getCommits({ limit, since, cwd });
+  const learnings = [];
+
+  for (const commit of commits) {
+    const categories = categorizeCommit(commit);
+
+    // Skip mundane commits
+    if (isMundaneCommit(commit)) continue;
+
+    const learning = {
+      hash: commit.hash,
+      date: commit.date,
+      categories,
+      summary: commit.subject,
+      details: commit.body || null,
+      importance: calculateImportance(commit, categories)
+    };
+
+    if (includeFiles) {
+      learning.files = getCommitFiles(commit.hash, cwd);
+    }
+
+    learnings.push(learning);
+  }
+
+  // Sort by importance
+  learnings.sort((a, b) => b.importance - a.importance);
+
+  return { learnings, total: commits.length };
+}
+
+/**
+ * Check if commit is mundane (low-value for memory)
+ */
+function isMundaneCommit(commit) {
+  const mundanePatterns = [
+    /^merge/i,
+    /^wip/i,
+    /^temp/i,
+    /^bump version/i,
+    /^update changelog/i,
+    /^lint/i,
+    /^format/i,
+    /^typo/i,
+    /^minor/i,
+    /^small/i
+  ];
+
+  return mundanePatterns.some(p => p.test(commit.subject));
+}
+
+/**
+ * Calculate importance score for a learning
+ */
+function calculateImportance(commit, categories) {
+  let score = 0;
+
+  // Category weights
+  const weights = {
+    DECISION: 10,
+    ARCHITECTURE: 9,
+    SECURITY: 8,
+    BUGFIX: 7,
+    PATTERN: 6,
+    PERFORMANCE: 5,
+    DEPENDENCY: 4,
+    CONFIG: 3,
+    GENERAL: 1
+  };
+
+  for (const cat of categories) {
+    score += weights[cat] || 1;
+  }
+
+  // Boost for longer messages (more context)
+  if (commit.body && commit.body.length > 50) {
+    score += 2;
+  }
+
+  // Boost for conventional commit prefixes
+  if (/^(feat|fix|refactor|perf|security):/i.test(commit.subject)) {
+    score += 2;
+  }
+
+  return score;
+}
+
+/**
+ * Group learnings by category
+ */
+function groupByCategory(learnings) {
+  const grouped = {};
+
+  for (const learning of learnings) {
+    for (const category of learning.categories) {
+      if (!grouped[category]) {
+        grouped[category] = [];
+      }
+      grouped[category].push(learning);
+    }
+  }
+
+  return grouped;
+}
+
+/**
+ * Generate markdown summary of learnings
+ */
+function toMarkdown(learnings, options = {}) {
+  const { title = 'Project Learnings', maxPerCategory = 5 } = options;
+  const grouped = groupByCategory(learnings);
+
+  let md = `## ${title}\n\n`;
+  md += `> Extracted from ${learnings.length} significant commits\n\n`;
+
+  for (const [category, items] of Object.entries(grouped)) {
+    const config = MEMORY_CATEGORIES[category] || { icon: '📝', label: category };
+    const topItems = items.slice(0, maxPerCategory);
+
+    md += `### ${config.icon} ${config.label}\n\n`;
+
+    for (const item of topItems) {
+      md += `- **${item.summary}**`;
+      if (item.details) {
+        // First line of details only
+        const firstLine = item.details.split('\n')[0].trim();
+        if (firstLine && firstLine.length < 100) {
+          md += ` - ${firstLine}`;
+        }
+      }
+      md += ` _(${item.hash})_\n`;
+    }
+
+    md += '\n';
+  }
+
+  return md;
+}
+
+/**
+ * Generate compact summary for CLAUDE.md injection
+ */
+function toCompactSummary(learnings, options = {}) {
+  const { maxItems = 15 } = options;
+  const topLearnings = learnings.slice(0, maxItems);
+
+  let summary = `## Recent Learnings\n\n`;
+  summary += `Key decisions and patterns from recent development:\n\n`;
+
+  for (const learning of topLearnings) {
+    const categoryIcons = learning.categories
+      .map(c => MEMORY_CATEGORIES[c]?.icon || '📝')
+      .join('');
+
+    summary += `- ${categoryIcons} ${learning.summary}\n`;
+  }
+
+  return summary;
+}
+
+/**
+ * Search learnings by keyword
+ */
+function searchLearnings(learnings, query) {
+  const queryLower = query.toLowerCase();
+
+  return learnings.filter(l => {
+    return l.summary.toLowerCase().includes(queryLower) ||
+           (l.details && l.details.toLowerCase().includes(queryLower)) ||
+           l.categories.some(c => c.toLowerCase().includes(queryLower));
+  });
+}
+
+/**
+ * Get learnings relevant to specific files
+ */
+function getLearningsForFiles(files, options = {}) {
+  const { cwd = process.cwd(), limit = 20 } = options;
+  const learnings = [];
+
+  for (const file of files) {
+    const commits = getCommits({ limit: 10, path: file, cwd });
+
+    for (const commit of commits) {
+      if (!isMundaneCommit(commit)) {
+        const categories = categorizeCommit(commit);
+        learnings.push({
+          hash: commit.hash,
+          date: commit.date,
+          categories,
+          summary: commit.subject,
+          details: commit.body,
+          file,
+          importance: calculateImportance(commit, categories)
+        });
+      }
+    }
+  }
+
+  // Dedupe by hash and sort
+  const seen = new Set();
+  return learnings
+    .filter(l => {
+      if (seen.has(l.hash)) return false;
+      seen.add(l.hash);
+      return true;
+    })
+    .sort((a, b) => b.importance - a.importance)
+    .slice(0, limit);
+}
+
+/**
+ * Get summary stats about the repo
+ */
+function getRepoStats(cwd = process.cwd()) {
+  if (!isGitRepo(cwd)) {
+    return null;
+  }
+
+  const totalCommits = parseInt(git('rev-list --count HEAD', { cwd }) || '0');
+  const firstCommit = git('log --reverse --pretty=format:"%ai" | head -1', { cwd });
+  const contributors = git('shortlog -sn --no-merges', { cwd })
+    .split('\n')
+    .filter(l => l.trim())
+    .length;
+
+  const recentActivity = git('log --since="1 week ago" --oneline', { cwd })
+    .split('\n')
+    .filter(l => l.trim())
+    .length;
+
+  return {
+    totalCommits,
+    firstCommit,
+    contributors,
+    recentActivity,
+    weeklyPace: recentActivity
+  };
+}
+
+// CLI
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const command = args[0] || 'summary';
+
+  switch (command) {
+    case 'extract': {
+      const result = extractLearnings({
+        limit: parseInt(args[1]) || 50,
+        includeFiles: args.includes('--files')
+      });
+
+      if (result.error) {
+        console.error(result.error);
+        process.exit(1);
+      }
+
+      console.log(JSON.stringify(result.learnings, null, 2));
+      break;
+    }
+
+    case 'summary': {
+      const result = extractLearnings({ limit: 50 });
+
+      if (result.error) {
+        console.error(result.error);
+        process.exit(1);
+      }
+
+      console.log(toMarkdown(result.learnings));
+      break;
+    }
+
+    case 'compact': {
+      const result = extractLearnings({ limit: 30 });
+
+      if (result.error) {
+        console.error(result.error);
+        process.exit(1);
+      }
+
+      console.log(toCompactSummary(result.learnings));
+      break;
+    }
+
+    case 'search': {
+      const query = args.slice(1).join(' ');
+      if (!query) {
+        console.error('Usage: git-memory.js search <query>');
+        process.exit(1);
+      }
+
+      const result = extractLearnings({ limit: 100 });
+      const matches = searchLearnings(result.learnings, query);
+
+      console.log(`Found ${matches.length} matches for "${query}":\n`);
+      for (const match of matches.slice(0, 10)) {
+        console.log(`  [${match.hash}] ${match.summary}`);
+      }
+      break;
+    }
+
+    case 'stats': {
+      const stats = getRepoStats();
+      if (!stats) {
+        console.error('Not a git repository');
+        process.exit(1);
+      }
+      console.log(JSON.stringify(stats, null, 2));
+      break;
+    }
+
+    case 'categories': {
+      console.log('\nAvailable categories:\n');
+      for (const [key, config] of Object.entries(MEMORY_CATEGORIES)) {
+        console.log(`  ${config.icon} ${key.padEnd(15)} ${config.label}`);
+      }
+      console.log();
+      break;
+    }
+
+    default:
+      console.log(`
+Bootspring Git Memory
+
+Usage:
+  git-memory.js extract [limit] [--files]   Extract learnings as JSON
+  git-memory.js summary                     Generate markdown summary
+  git-memory.js compact                     Compact summary for CLAUDE.md
+  git-memory.js search <query>              Search learnings
+  git-memory.js stats                       Repository statistics
+  git-memory.js categories                  List memory categories
+`);
+  }
+}
+
+module.exports = {
+  isGitRepo,
+  getCommits,
+  extractLearnings,
+  groupByCategory,
+  toMarkdown,
+  toCompactSummary,
+  searchLearnings,
+  getLearningsForFiles,
+  getRepoStats,
+  MEMORY_CATEGORIES
+};

package/intelligence/index.js

@@ -0,0 +1,59 @@
+/**
+ * Bootspring Intelligence Module
+ *
+ * Provides intelligent agent orchestration, context analysis,
+ * workflow management, and autonomous loop execution.
+ *
+ * @package bootspring
+ * @module intelligence
+ */
+
+const orchestrator = require('./orchestrator');
+const prd = require('./prd');
+const gitMemory = require('./git-memory');
+const recommendations = require('./recommendations');
+
+module.exports = {
+  // Orchestrator functions
+  analyzeContext: orchestrator.analyzeContext,
+  getWorkflow: orchestrator.getWorkflow,
+  listWorkflows: orchestrator.listWorkflows,
+  startWorkflow: orchestrator.startWorkflow,
+  advanceWorkflow: orchestrator.advanceWorkflow,
+  markWorkflowCheckpoint: orchestrator.markWorkflowCheckpoint,
+  getWorkflowSignalProgress: orchestrator.getWorkflowSignalProgress,
+  loadState: orchestrator.loadState,
+  saveState: orchestrator.saveState,
+  getCurrentPhase: orchestrator.getCurrentPhase,
+  agentExists: orchestrator.agentExists,
+  getAvailableAgents: orchestrator.getAvailableAgents,
+
+  // PRD functions
+  createPRD: prd.createPRD,
+  loadPRD: prd.loadPRD,
+  savePRD: prd.savePRD,
+  getNextStory: prd.getNextStory,
+  updateStoryStatus: prd.updateStoryStatus,
+  getPRDProgress: prd.getProgress,
+  isPRDComplete: prd.isComplete,
+  parseMarkdownPRD: prd.parseMarkdownPRD,
+  prdToMarkdown: prd.toMarkdown,
+
+  // Git Memory functions
+  extractLearnings: gitMemory.extractLearnings,
+  getLearningsForFiles: gitMemory.getLearningsForFiles,
+  searchLearnings: gitMemory.searchLearnings,
+  learningsToMarkdown: gitMemory.toMarkdown,
+  learningsToCompact: gitMemory.toCompactSummary,
+  getRepoStats: gitMemory.getRepoStats,
+  isGitRepo: gitMemory.isGitRepo,
+  MEMORY_CATEGORIES: gitMemory.MEMORY_CATEGORIES,
+
+  // Recommendation engine
+  createRecommendationsEngine: recommendations.createRecommendationsEngine,
+
+  // Constants
+  PHASE_AGENTS: orchestrator.PHASE_AGENTS,
+  TECHNICAL_TRIGGERS: orchestrator.TECHNICAL_TRIGGERS,
+  WORKFLOWS: orchestrator.WORKFLOWS
+};