@girardmedia/bootspring 1.2.0 → 2.0.3

package/hooks/git-autopilot.js

@@ -0,0 +1,1250 @@
+/**
+ * Bootspring Git Autopilot
+ *
+ * Automatically triggers workflows based on git events.
+ * Monitors git activity and starts appropriate workflows.
+ *
+ * Features:
+ * - Real-time git event watching (commits, branches, merges)
+ * - Configurable via bootspring.config.js
+ * - Integration with orchestrator workflows
+ * - Smart pattern matching for branch names and commit messages
+ *
+ * @package bootspring
+ * @module hooks/git-autopilot
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const EventEmitter = require('events');
+
+/**
+ * Git event to workflow mapping
+ */
+const EVENT_WORKFLOWS = {
+  // Branch patterns
+  'branch:feature/*': 'feature-development',
+  'branch:feat/*': 'feature-development',
+  'branch:fix/*': 'feature-development',
+  'branch:hotfix/*': 'security-audit',
+  'branch:release/*': 'launch-preparation',
+  'branch:perf/*': 'performance-optimization',
+  'branch:security/*': 'security-audit',
+  'branch:api/*': 'api-development',
+  'branch:db/*': 'database-migration',
+  'branch:migration/*': 'database-migration',
+
+  // Commit message patterns
+  'commit:feat:': 'feature-development',
+  'commit:feature:': 'feature-development',
+  'commit:fix:': 'feature-development',
+  'commit:security:': 'security-audit',
+  'commit:perf:': 'performance-optimization',
+  'commit:refactor:': 'performance-optimization',
+  'commit:db:': 'database-migration',
+  'commit:migration:': 'database-migration',
+
+  // File change patterns
+  'files:prisma/': 'database-migration',
+  'files:schema.prisma': 'database-migration',
+  'files:src/api/': 'api-development',
+  'files:app/api/': 'api-development',
+  'files:pages/api/': 'api-development',
+
+  // Merge patterns
+  'merge:main': 'launch-preparation',
+  'merge:master': 'launch-preparation',
+  'merge:production': 'launch-preparation',
+
+  // Tag patterns
+  'tag:v*': 'launch-preparation',
+  'tag:release-*': 'launch-preparation'
+};
+
+/**
+ * Autopilot configuration defaults
+ */
+const DEFAULT_CONFIG = {
+  enabled: false,
+  autoStart: false,       // Automatically start suggested workflow
+  requireConfirmation: true,
+  watchInterval: 5000,    // Interval for polling git state (ms)
+  ignoreBranches: ['main', 'master', 'develop'],
+  ignorePatterns: ['wip:', 'WIP:', '[skip ci]', '[skip workflow]'],
+  eventMapping: EVENT_WORKFLOWS,
+  hooks: {
+    onBranchCreate: true,
+    onCommit: true,
+    onMerge: true,
+    onTag: true,
+    onFileChange: true
+  },
+  // Security: only allow specific workflows to auto-start
+  allowedAutoStartWorkflows: [
+    'feature-development',
+    'api-development'
+  ],
+  // Cooldown period between workflow triggers (ms)
+  cooldownPeriod: 60000
+};
+
+/**
+ * Git Autopilot Event Emitter
+ * Emits events for git activities
+ */
+class GitAutopilotEmitter extends EventEmitter {}
+const autopilotEmitter = new GitAutopilotEmitter();
+
+/**
+ * In-memory state for the watcher
+ */
+const watcherState = {
+  isWatching: false,
+  watcherId: null,
+  lastBranch: null,
+  lastCommit: null,
+  lastMergeBase: null,
+  lastTags: [],
+  lastTriggerTime: 0,
+  processedCommits: new Set()
+};
+
+/**
+ * Get autopilot state file path
+ */
+function getAutopilotPath() {
+  const projectRoot = process.cwd();
+  return path.join(projectRoot, '.bootspring', 'autopilot-state.json');
+}
+
+/**
+ * Load configuration from bootspring.config.js
+ */
+function loadConfig() {
+  const projectRoot = process.cwd();
+  const configPaths = [
+    path.join(projectRoot, 'bootspring.config.js'),
+    path.join(projectRoot, 'bootspring.config.mjs'),
+    path.join(projectRoot, '.bootspringrc.js')
+  ];
+
+  for (const configPath of configPaths) {
+    if (fs.existsSync(configPath)) {
+      try {
+        // Clear require cache to get fresh config
+        delete require.cache[require.resolve(configPath)];
+        const config = require(configPath);
+
+        if (config.autopilot || config.gitAutopilot) {
+          return mergeConfig(DEFAULT_CONFIG, config.autopilot || config.gitAutopilot);
+        }
+      } catch (err) {
+        console.warn(`Failed to load config from ${configPath}:`, err.message);
+      }
+    }
+  }
+
+  return DEFAULT_CONFIG;
+}
+
+/**
+ * Deep merge configuration objects
+ */
+function mergeConfig(defaults, overrides) {
+  const result = { ...defaults };
+
+  for (const [key, value] of Object.entries(overrides)) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+      result[key] = mergeConfig(defaults[key] || {}, value);
+    } else {
+      result[key] = value;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Load autopilot state
+ */
+function loadAutopilotState() {
+  const statePath = getAutopilotPath();
+  if (fs.existsSync(statePath)) {
+    try {
+      const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+      // Load config from bootspring.config.js first
+      const fileConfig = loadConfig();
+      // Merge: defaults <- file config <- persisted state config
+      // This ensures persisted runtime state (enabled, autoStart) takes precedence
+      state.config = mergeConfig(mergeConfig(DEFAULT_CONFIG, fileConfig), state.config || {});
+      return state;
+    } catch {
+      return createDefaultState();
+    }
+  }
+  return createDefaultState();
+}
+
+/**
+ * Create default autopilot state
+ */
+function createDefaultState() {
+  const config = loadConfig();
+  return {
+    config,
+    lastCheck: null,
+    pendingSuggestions: [],
+    history: [],
+    triggeredWorkflows: [],
+    watcherActive: false
+  };
+}
+
+/**
+ * Save autopilot state
+ */
+function saveAutopilotState(state) {
+  const statePath = getAutopilotPath();
+  const dir = path.dirname(statePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  state.lastUpdated = new Date().toISOString();
+  fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
+}
+
+/**
+ * Get current git branch
+ */
+function getCurrentBranch() {
+  try {
+    return execSync('git branch --show-current', { encoding: 'utf-8' }).trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get the current HEAD commit hash
+ */
+function getCurrentCommit() {
+  try {
+    return execSync('git rev-parse HEAD', { encoding: 'utf-8' }).trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get recent commits
+ */
+function getRecentCommits(count = 5) {
+  try {
+    const output = execSync(`git log -${count} --pretty=format:"%H|%s|%an|%ai"`, { encoding: 'utf-8' });
+    return output.split('\n').filter(Boolean).map(line => {
+      const [hash, message, author, date] = line.split('|');
+      return { hash, message, author, date };
+    });
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Get changed files in recent commits
+ */
+function getChangedFiles(count = 5) {
+  try {
+    const output = execSync(`git diff --name-only HEAD~${count}..HEAD 2>/dev/null || git diff --name-only HEAD`, { encoding: 'utf-8' });
+    return output.split('\n').filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Get recent tags
+ */
+function getRecentTags(count = 3) {
+  try {
+    const output = execSync(`git tag --sort=-creatordate 2>/dev/null | head -${count}`, { encoding: 'utf-8', shell: true });
+    return output.split('\n').filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Check if current branch was recently merged from another
+ */
+function checkForMerge(targetBranch = 'main') {
+  try {
+    // Get the merge base between HEAD and the target branch
+    const mergeBase = execSync(`git merge-base HEAD origin/${targetBranch} 2>/dev/null || echo ""`, {
+      encoding: 'utf-8',
+      shell: true
+    }).trim();
+
+    // Check if HEAD is an ancestor of target branch (meaning we merged TO it)
+    const isMerged = execSync(`git branch -r --contains HEAD 2>/dev/null | grep -E "origin/${targetBranch}$" || echo ""`, {
+      encoding: 'utf-8',
+      shell: true
+    }).trim();
+
+    return {
+      mergeBase,
+      isMerged: isMerged.length > 0,
+      targetBranch
+    };
+  } catch {
+    return { mergeBase: null, isMerged: false, targetBranch };
+  }
+}
+
+/**
+ * Detect if a new branch was created
+ */
+function detectBranchCreation() {
+  try {
+    // Check if this branch has only a few commits that aren't on main/master
+    const baseCommitCount = execSync(
+      'git rev-list --count HEAD ^origin/main 2>/dev/null || git rev-list --count HEAD ^origin/master 2>/dev/null || echo "0"',
+      { encoding: 'utf-8', shell: true }
+    ).trim();
+
+    const count = parseInt(baseCommitCount, 10);
+
+    // If less than 5 unique commits, likely a new feature branch
+    return count > 0 && count < 5;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Match a pattern against a value
+ */
+function matchPattern(pattern, value) {
+  // Simple glob matching
+  const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+  return regex.test(value);
+}
+
+/**
+ * Check if a message should be ignored
+ */
+function shouldIgnoreMessage(message, ignorePatterns) {
+  const msgLower = message.toLowerCase();
+  return ignorePatterns.some(pattern =>
+    msgLower.includes(pattern.toLowerCase())
+  );
+}
+
+/**
+ * Analyze git state and suggest workflow
+ */
+function analyzeGitState(options = {}) {
+  const state = loadAutopilotState();
+
+  if (!state.config.enabled && !options.force) {
+    return { enabled: false, suggestions: [] };
+  }
+
+  const config = state.config;
+  const branch = getCurrentBranch();
+  const commits = getRecentCommits();
+  const files = getChangedFiles();
+  const tags = getRecentTags();
+  const mergeInfo = checkForMerge('main');
+  const isNewBranch = detectBranchCreation();
+
+  const suggestions = [];
+  const mapping = config.eventMapping || EVENT_WORKFLOWS;
+
+  // Check branch patterns
+  if (branch && !config.ignoreBranches.includes(branch)) {
+    for (const [pattern, workflow] of Object.entries(mapping)) {
+      if (pattern.startsWith('branch:')) {
+        const branchPattern = pattern.replace('branch:', '');
+        if (matchPattern(branchPattern, branch)) {
+          suggestions.push({
+            trigger: 'branch',
+            triggerType: isNewBranch ? 'branch_create' : 'branch_active',
+            pattern: branchPattern,
+            value: branch,
+            workflow,
+            confidence: isNewBranch ? 0.9 : 0.7,
+            isNewBranch,
+            autoStartEligible: config.allowedAutoStartWorkflows.includes(workflow)
+          });
+        }
+      }
+    }
+  }
+
+  // Check merge patterns
+  if (config.hooks.onMerge && mergeInfo.isMerged) {
+    for (const [pattern, workflow] of Object.entries(mapping)) {
+      if (pattern.startsWith('merge:')) {
+        const targetBranch = pattern.replace('merge:', '');
+        if (mergeInfo.targetBranch === targetBranch ||
+            matchPattern(targetBranch, mergeInfo.targetBranch)) {
+          suggestions.push({
+            trigger: 'merge',
+            triggerType: 'merge_to_main',
+            pattern: targetBranch,
+            value: `Merged to ${mergeInfo.targetBranch}`,
+            workflow,
+            confidence: 0.95,
+            mergeBase: mergeInfo.mergeBase,
+            autoStartEligible: config.allowedAutoStartWorkflows.includes(workflow)
+          });
+        }
+      }
+    }
+  }
+
+  // Check commit message patterns
+  if (config.hooks.onCommit) {
+    for (const commit of commits) {
+      // Skip ignored patterns
+      if (shouldIgnoreMessage(commit.message, config.ignorePatterns)) {
+        continue;
+      }
+
+      // Skip already processed commits
+      if (watcherState.processedCommits.has(commit.hash)) {
+        continue;
+      }
+
+      for (const [pattern, workflow] of Object.entries(mapping)) {
+        if (pattern.startsWith('commit:')) {
+          const messagePattern = pattern.replace('commit:', '');
+          if (commit.message.toLowerCase().startsWith(messagePattern)) {
+            suggestions.push({
+              trigger: 'commit',
+              triggerType: 'commit_message',
+              pattern: messagePattern,
+              value: commit.message,
+              workflow,
+              confidence: 0.8,
+              commitHash: commit.hash,
+              autoStartEligible: config.allowedAutoStartWorkflows.includes(workflow)
+            });
+            break; // Only one suggestion per commit
+          }
+        }
+      }
+    }
+  }
+
+  // Check file patterns
+  if (config.hooks.onFileChange) {
+    for (const file of files) {
+      for (const [pattern, workflow] of Object.entries(mapping)) {
+        if (pattern.startsWith('files:')) {
+          const filePattern = pattern.replace('files:', '');
+          if (file.startsWith(filePattern) || file.includes(filePattern)) {
+            suggestions.push({
+              trigger: 'file',
+              triggerType: 'file_change',
+              pattern: filePattern,
+              value: file,
+              workflow,
+              confidence: 0.7,
+              autoStartEligible: config.allowedAutoStartWorkflows.includes(workflow)
+            });
+            break; // Only one suggestion per file
+          }
+        }
+      }
+    }
+  }
+
+  // Check tag patterns
+  if (config.hooks.onTag) {
+    for (const tag of tags) {
+      for (const [pattern, workflow] of Object.entries(mapping)) {
+        if (pattern.startsWith('tag:')) {
+          const tagPattern = pattern.replace('tag:', '');
+          if (matchPattern(tagPattern, tag)) {
+            suggestions.push({
+              trigger: 'tag',
+              triggerType: 'tag_create',
+              pattern: tagPattern,
+              value: tag,
+              workflow,
+              confidence: 0.95,
+              autoStartEligible: config.allowedAutoStartWorkflows.includes(workflow)
+            });
+          }
+        }
+      }
+    }
+  }
+
+  // Deduplicate by workflow (keep highest confidence)
+  const uniqueWorkflows = new Map();
+  for (const suggestion of suggestions) {
+    const existing = uniqueWorkflows.get(suggestion.workflow);
+    if (!existing || existing.confidence < suggestion.confidence) {
+      uniqueWorkflows.set(suggestion.workflow, suggestion);
+    }
+  }
+
+  const finalSuggestions = Array.from(uniqueWorkflows.values())
+    .sort((a, b) => b.confidence - a.confidence);
+
+  // Update state
+  state.lastCheck = new Date().toISOString();
+  state.pendingSuggestions = finalSuggestions;
+  saveAutopilotState(state);
+
+  return {
+    enabled: true,
+    branch,
+    isNewBranch,
+    mergeInfo,
+    suggestions: finalSuggestions,
+    autoStartEnabled: config.autoStart
+  };
+}
+
+/**
+ * Enable autopilot
+ */
+function enable(options = {}) {
+  const state = loadAutopilotState();
+  state.config.enabled = true;
+  state.config = { ...state.config, ...options };
+
+  state.history.push({
+    action: 'enabled',
+    timestamp: new Date().toISOString(),
+    options
+  });
+
+  saveAutopilotState(state);
+
+  return { success: true, config: state.config };
+}
+
+/**
+ * Disable autopilot
+ */
+function disable() {
+  const state = loadAutopilotState();
+  state.config.enabled = false;
+
+  // Stop watcher if running
+  if (watcherState.isWatching) {
+    stopWatcher();
+  }
+
+  state.history.push({
+    action: 'disabled',
+    timestamp: new Date().toISOString()
+  });
+
+  saveAutopilotState(state);
+
+  return { success: true };
+}
+
+/**
+ * Get autopilot status
+ */
+function getStatus() {
+  const state = loadAutopilotState();
+  return {
+    enabled: state.config.enabled,
+    config: state.config,
+    lastCheck: state.lastCheck,
+    pendingSuggestions: state.pendingSuggestions.length,
+    suggestions: state.pendingSuggestions,
+    watcherActive: watcherState.isWatching,
+    triggeredWorkflows: state.triggeredWorkflows || []
+  };
+}
+
+/**
+ * Accept a workflow suggestion
+ * @param {string} workflow - Workflow name to accept
+ */
+function acceptSuggestion(workflow) {
+  const state = loadAutopilotState();
+
+  const suggestion = state.pendingSuggestions.find(s => s.workflow === workflow);
+  if (!suggestion) {
+    return { success: false, error: 'Suggestion not found' };
+  }
+
+  // Remove from pending
+  state.pendingSuggestions = state.pendingSuggestions.filter(s => s.workflow !== workflow);
+
+  state.history.push({
+    action: 'suggestion_accepted',
+    workflow,
+    trigger: suggestion.trigger,
+    triggerType: suggestion.triggerType,
+    timestamp: new Date().toISOString()
+  });
+
+  // Track triggered workflows
+  state.triggeredWorkflows = state.triggeredWorkflows || [];
+  state.triggeredWorkflows.push({
+    workflow,
+    trigger: suggestion.trigger,
+    timestamp: new Date().toISOString()
+  });
+
+  saveAutopilotState(state);
+
+  // Start the workflow
+  const orchestrator = require('../intelligence/orchestrator');
+  const result = orchestrator.startWorkflow(workflow);
+
+  // Emit event
+  autopilotEmitter.emit('workflow:started', {
+    workflow,
+    trigger: suggestion.trigger,
+    triggerType: suggestion.triggerType,
+    result
+  });
+
+  return {
+    success: true,
+    workflow,
+    startResult: result
+  };
+}
+
+/**
+ * Dismiss a workflow suggestion
+ * @param {string} workflow - Workflow name to dismiss
+ */
+function dismissSuggestion(workflow) {
+  const state = loadAutopilotState();
+
+  state.pendingSuggestions = state.pendingSuggestions.filter(s => s.workflow !== workflow);
+
+  state.history.push({
+    action: 'suggestion_dismissed',
+    workflow,
+    timestamp: new Date().toISOString()
+  });
+
+  saveAutopilotState(state);
+
+  return { success: true, workflow };
+}
+
+/**
+ * Add custom event mapping
+ * @param {string} pattern - Event pattern (e.g., 'branch:custom/*')
+ * @param {string} workflow - Workflow to trigger
+ */
+function addEventMapping(pattern, workflow) {
+  const state = loadAutopilotState();
+  state.config.eventMapping = state.config.eventMapping || {};
+  state.config.eventMapping[pattern] = workflow;
+  saveAutopilotState(state);
+
+  return { success: true, pattern, workflow };
+}
+
+/**
+ * Remove event mapping
+ * @param {string} pattern - Event pattern to remove
+ */
+function removeEventMapping(pattern) {
+  const state = loadAutopilotState();
+  if (state.config.eventMapping && state.config.eventMapping[pattern]) {
+    delete state.config.eventMapping[pattern];
+    saveAutopilotState(state);
+    return { success: true, pattern };
+  }
+  return { success: false, error: 'Pattern not found' };
+}
+
+/**
+ * Start the git watcher
+ * Monitors git state and triggers workflows automatically
+ */
+function startWatcher() {
+  const state = loadAutopilotState();
+
+  if (!state.config.enabled) {
+    return { success: false, error: 'Autopilot is not enabled. Call enable() first.' };
+  }
+
+  if (watcherState.isWatching) {
+    return { success: false, error: 'Watcher is already running' };
+  }
+
+  // Initialize watcher state
+  watcherState.lastBranch = getCurrentBranch();
+  watcherState.lastCommit = getCurrentCommit();
+  watcherState.lastTags = getRecentTags();
+  watcherState.isWatching = true;
+  watcherState.processedCommits = new Set();
+
+  const interval = state.config.watchInterval || 5000;
+
+  // Start the polling interval
+  watcherState.watcherId = setInterval(() => {
+    pollGitState();
+  }, interval);
+
+  // Update state
+  state.watcherActive = true;
+  state.watcherStartedAt = new Date().toISOString();
+  saveAutopilotState(state);
+
+  autopilotEmitter.emit('watcher:started', { interval });
+
+  return {
+    success: true,
+    interval,
+    message: `Git watcher started. Polling every ${interval}ms`
+  };
+}
+
+/**
+ * Stop the git watcher
+ */
+function stopWatcher() {
+  if (!watcherState.isWatching) {
+    return { success: false, error: 'Watcher is not running' };
+  }
+
+  if (watcherState.watcherId) {
+    clearInterval(watcherState.watcherId);
+    watcherState.watcherId = null;
+  }
+
+  watcherState.isWatching = false;
+
+  const state = loadAutopilotState();
+  state.watcherActive = false;
+  state.watcherStoppedAt = new Date().toISOString();
+  saveAutopilotState(state);
+
+  autopilotEmitter.emit('watcher:stopped', {});
+
+  return { success: true, message: 'Git watcher stopped' };
+}
+
+/**
+ * Poll git state for changes
+ * Called periodically by the watcher
+ */
+function pollGitState() {
+  const state = loadAutopilotState();
+  const config = state.config;
+
+  // Check for branch change
+  const currentBranch = getCurrentBranch();
+  if (currentBranch !== watcherState.lastBranch) {
+    const isNewBranch = detectBranchCreation();
+
+    autopilotEmitter.emit('git:branch_change', {
+      from: watcherState.lastBranch,
+      to: currentBranch,
+      isNew: isNewBranch
+    });
+
+    if (isNewBranch && config.hooks.onBranchCreate) {
+      handleBranchCreate(currentBranch);
+    }
+
+    watcherState.lastBranch = currentBranch;
+  }
+
+  // Check for new commits
+  const currentCommit = getCurrentCommit();
+  if (currentCommit !== watcherState.lastCommit) {
+    autopilotEmitter.emit('git:commit', {
+      from: watcherState.lastCommit,
+      to: currentCommit
+    });
+
+    if (config.hooks.onCommit) {
+      handleNewCommit(currentCommit);
+    }
+
+    watcherState.lastCommit = currentCommit;
+  }
+
+  // Check for merges to main
+  if (config.hooks.onMerge) {
+    const mergeInfo = checkForMerge('main');
+    if (mergeInfo.isMerged && mergeInfo.mergeBase !== watcherState.lastMergeBase) {
+      autopilotEmitter.emit('git:merge', {
+        targetBranch: mergeInfo.targetBranch,
+        mergeBase: mergeInfo.mergeBase
+      });
+
+      handleMerge(mergeInfo);
+      watcherState.lastMergeBase = mergeInfo.mergeBase;
+    }
+  }
+
+  // Check for new tags
+  if (config.hooks.onTag) {
+    const currentTags = getRecentTags();
+    const newTags = currentTags.filter(t => !watcherState.lastTags.includes(t));
+
+    if (newTags.length > 0) {
+      autopilotEmitter.emit('git:tag', { newTags });
+      handleNewTags(newTags);
+      watcherState.lastTags = currentTags;
+    }
+  }
+}
+
+/**
+ * Handle branch creation event
+ */
+function handleBranchCreate(branch) {
+  const state = loadAutopilotState();
+  const config = state.config;
+
+  // Skip ignored branches
+  if (config.ignoreBranches.includes(branch)) {
+    return;
+  }
+
+  // Check cooldown
+  if (Date.now() - watcherState.lastTriggerTime < config.cooldownPeriod) {
+    return;
+  }
+
+  // Find matching workflow
+  for (const [pattern, workflow] of Object.entries(config.eventMapping)) {
+    if (pattern.startsWith('branch:')) {
+      const branchPattern = pattern.replace('branch:', '');
+      if (matchPattern(branchPattern, branch)) {
+        const suggestion = {
+          trigger: 'branch',
+          triggerType: 'branch_create',
+          pattern: branchPattern,
+          value: branch,
+          workflow,
+          confidence: 0.9,
+          isNewBranch: true,
+          autoStartEligible: config.allowedAutoStartWorkflows.includes(workflow),
+          timestamp: new Date().toISOString()
+        };
+
+        // Add to pending suggestions
+        state.pendingSuggestions = state.pendingSuggestions || [];
+        state.pendingSuggestions.push(suggestion);
+        saveAutopilotState(state);
+
+        autopilotEmitter.emit('suggestion:created', suggestion);
+
+        // Auto-start if configured
+        if (config.autoStart && suggestion.autoStartEligible) {
+          watcherState.lastTriggerTime = Date.now();
+          acceptSuggestion(workflow);
+        }
+
+        return; // Only one workflow per branch
+      }
+    }
+  }
+}
+
+/**
+ * Handle new commit event
+ */
+function handleNewCommit(commitHash) {
+  const state = loadAutopilotState();
+  const config = state.config;
+
+  // Skip if already processed
+  if (watcherState.processedCommits.has(commitHash)) {
+    return;
+  }
+
+  // Get commit details
+  const commits = getRecentCommits(1);
+  if (commits.length === 0) return;
+
+  const commit = commits[0];
+
+  // Skip ignored patterns
+  if (shouldIgnoreMessage(commit.message, config.ignorePatterns)) {
+    watcherState.processedCommits.add(commitHash);
+    return;
+  }
+
+  // Check cooldown
+  if (Date.now() - watcherState.lastTriggerTime < config.cooldownPeriod) {
+    watcherState.processedCommits.add(commitHash);
+    return;
+  }
+
+  // Find matching workflow
+  for (const [pattern, workflow] of Object.entries(config.eventMapping)) {
+    if (pattern.startsWith('commit:')) {
+      const messagePattern = pattern.replace('commit:', '');
+      if (commit.message.toLowerCase().startsWith(messagePattern)) {
+        const suggestion = {
+          trigger: 'commit',
+          triggerType: 'commit_message',
+          pattern: messagePattern,
+          value: commit.message,
+          workflow,
+          confidence: 0.8,
+          commitHash,
+          autoStartEligible: config.allowedAutoStartWorkflows.includes(workflow),
+          timestamp: new Date().toISOString()
+        };
+
+        // Add to pending suggestions
+        state.pendingSuggestions = state.pendingSuggestions || [];
+        state.pendingSuggestions.push(suggestion);
+        saveAutopilotState(state);
+
+        autopilotEmitter.emit('suggestion:created', suggestion);
+
+        // Auto-start if configured
+        if (config.autoStart && suggestion.autoStartEligible) {
+          watcherState.lastTriggerTime = Date.now();
+          acceptSuggestion(workflow);
+        }
+
+        watcherState.processedCommits.add(commitHash);
+        return; // Only one workflow per commit
+      }
+    }
+  }
+
+  watcherState.processedCommits.add(commitHash);
+}
+
+/**
+ * Handle merge event
+ */
+function handleMerge(mergeInfo) {
+  const state = loadAutopilotState();
+  const config = state.config;
+
+  // Check cooldown
+  if (Date.now() - watcherState.lastTriggerTime < config.cooldownPeriod) {
+    return;
+  }
+
+  // Find matching workflow
+  for (const [pattern, workflow] of Object.entries(config.eventMapping)) {
+    if (pattern.startsWith('merge:')) {
+      const targetBranch = pattern.replace('merge:', '');
+      if (mergeInfo.targetBranch === targetBranch ||
+          matchPattern(targetBranch, mergeInfo.targetBranch)) {
+        const suggestion = {
+          trigger: 'merge',
+          triggerType: 'merge_to_main',
+          pattern: targetBranch,
+          value: `Merged to ${mergeInfo.targetBranch}`,
+          workflow,
+          confidence: 0.95,
+          mergeBase: mergeInfo.mergeBase,
+          autoStartEligible: config.allowedAutoStartWorkflows.includes(workflow),
+          timestamp: new Date().toISOString()
+        };
+
+        // Add to pending suggestions
+        state.pendingSuggestions = state.pendingSuggestions || [];
+        state.pendingSuggestions.push(suggestion);
+        saveAutopilotState(state);
+
+        autopilotEmitter.emit('suggestion:created', suggestion);
+
+        // Always suggest launch-preparation on merge to main, but don't auto-start
+        // as it's a critical workflow
+        if (config.autoStart && suggestion.autoStartEligible) {
+          watcherState.lastTriggerTime = Date.now();
+          acceptSuggestion(workflow);
+        }
+
+        return; // Only one workflow per merge
+      }
+    }
+  }
+}
+
+/**
+ * Handle new tags event
+ */
+function handleNewTags(tags) {
+  const state = loadAutopilotState();
+  const config = state.config;
+
+  // Check cooldown
+  if (Date.now() - watcherState.lastTriggerTime < config.cooldownPeriod) {
+    return;
+  }
+
+  for (const tag of tags) {
+    for (const [pattern, workflow] of Object.entries(config.eventMapping)) {
+      if (pattern.startsWith('tag:')) {
+        const tagPattern = pattern.replace('tag:', '');
+        if (matchPattern(tagPattern, tag)) {
+          const suggestion = {
+            trigger: 'tag',
+            triggerType: 'tag_create',
+            pattern: tagPattern,
+            value: tag,
+            workflow,
+            confidence: 0.95,
+            autoStartEligible: config.allowedAutoStartWorkflows.includes(workflow),
+            timestamp: new Date().toISOString()
+          };
+
+          // Add to pending suggestions
+          state.pendingSuggestions = state.pendingSuggestions || [];
+          state.pendingSuggestions.push(suggestion);
+          saveAutopilotState(state);
+
+          autopilotEmitter.emit('suggestion:created', suggestion);
+
+          // Tags usually indicate releases - don't auto-start
+          if (config.autoStart && suggestion.autoStartEligible) {
+            watcherState.lastTriggerTime = Date.now();
+            acceptSuggestion(workflow);
+          }
+
+          return; // Only one workflow per tag
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Install git hooks for real-time triggering
+ * This provides more immediate response than polling
+ */
+function installGitHooks() {
+  const projectRoot = process.cwd();
+  const hooksDir = path.join(projectRoot, '.git', 'hooks');
+
+  if (!fs.existsSync(hooksDir)) {
+    return { success: false, error: 'Not a git repository or .git/hooks not found' };
+  }
+
+  const hooks = {
+    'post-commit': `#!/bin/sh
+# Bootspring Git Autopilot - Post Commit Hook
+node -e "try { require('bootspring/hooks/git-autopilot').onGitHook('post-commit'); } catch(e) {}" 2>/dev/null || true
+`,
+    'post-checkout': `#!/bin/sh
+# Bootspring Git Autopilot - Post Checkout Hook
+# $3 is 1 if this is a branch checkout
+if [ "$3" = "1" ]; then
+  node -e "try { require('bootspring/hooks/git-autopilot').onGitHook('post-checkout', { branch: true }); } catch(e) {}" 2>/dev/null || true
+fi
+`,
+    'post-merge': `#!/bin/sh
+# Bootspring Git Autopilot - Post Merge Hook
+node -e "try { require('bootspring/hooks/git-autopilot').onGitHook('post-merge'); } catch(e) {}" 2>/dev/null || true
+`
+  };
+
+  const installed = [];
+  const skipped = [];
+
+  for (const [hookName, hookContent] of Object.entries(hooks)) {
+    const hookPath = path.join(hooksDir, hookName);
+
+    // Check if hook already exists
+    if (fs.existsSync(hookPath)) {
+      const existing = fs.readFileSync(hookPath, 'utf8');
+      if (existing.includes('Bootspring Git Autopilot')) {
+        skipped.push(hookName);
+        continue;
+      }
+      // Append to existing hook
+      fs.appendFileSync(hookPath, '\n' + hookContent);
+    } else {
+      fs.writeFileSync(hookPath, hookContent);
+    }
+
+    // Make executable
+    fs.chmodSync(hookPath, '755');
+    installed.push(hookName);
+  }
+
+  return {
+    success: true,
+    installed,
+    skipped,
+    message: `Installed ${installed.length} hooks, skipped ${skipped.length} (already present)`
+  };
+}
+
+/**
+ * Remove git hooks
+ */
+function removeGitHooks() {
+  const projectRoot = process.cwd();
+  const hooksDir = path.join(projectRoot, '.git', 'hooks');
+
+  if (!fs.existsSync(hooksDir)) {
+    return { success: false, error: 'Not a git repository' };
+  }
+
+  const hookNames = ['post-commit', 'post-checkout', 'post-merge'];
+  const removed = [];
+
+  for (const hookName of hookNames) {
+    const hookPath = path.join(hooksDir, hookName);
+
+    if (fs.existsSync(hookPath)) {
+      const content = fs.readFileSync(hookPath, 'utf8');
+
+      if (content.includes('Bootspring Git Autopilot')) {
+        // Remove bootspring-specific lines
+        const lines = content.split('\n');
+        const filtered = lines.filter(line =>
+          !line.includes('Bootspring Git Autopilot') &&
+          !line.includes('bootspring/hooks/git-autopilot')
+        );
+
+        if (filtered.filter(l => l.trim() && !l.startsWith('#!')).length === 0) {
+          // If only shebang remains, delete the file
+          fs.unlinkSync(hookPath);
+        } else {
+          fs.writeFileSync(hookPath, filtered.join('\n'));
+        }
+        removed.push(hookName);
+      }
+    }
+  }
+
+  return {
+    success: true,
+    removed,
+    message: `Removed ${removed.length} hooks`
+  };
+}
+
+/**
+ * Git hook handler - called from git hooks
+ */
+function onGitHook(hookType, options = {}) {
+  const state = loadAutopilotState();
+
+  if (!state.config.enabled) {
+    return;
+  }
+
+  switch (hookType) {
+    case 'post-commit':
+      if (state.config.hooks.onCommit) {
+        const commit = getCurrentCommit();
+        handleNewCommit(commit);
+      }
+      break;
+
+    case 'post-checkout':
+      if (options.branch && state.config.hooks.onBranchCreate) {
+        const branch = getCurrentBranch();
+        const isNew = detectBranchCreation();
+        if (isNew) {
+          handleBranchCreate(branch);
+        }
+      }
+      break;
+
+    case 'post-merge':
+      if (state.config.hooks.onMerge) {
+        const mergeInfo = checkForMerge('main');
+        if (mergeInfo.isMerged) {
+          handleMerge(mergeInfo);
+        }
+      }
+      break;
+  }
+}
+
+/**
+ * Update configuration
+ */
+function updateConfig(updates) {
+  const state = loadAutopilotState();
+  state.config = mergeConfig(state.config, updates);
+  saveAutopilotState(state);
+  return { success: true, config: state.config };
+}
+
+/**
+ * Get event emitter for custom handlers
+ */
+function getEmitter() {
+  return autopilotEmitter;
+}
+
+/**
+ * Clear all pending suggestions
+ */
+function clearSuggestions() {
+  const state = loadAutopilotState();
+  const count = state.pendingSuggestions.length;
+  state.pendingSuggestions = [];
+  saveAutopilotState(state);
+  return { success: true, cleared: count };
+}
+
+/**
+ * Get history of autopilot actions
+ */
+function getHistory(limit = 50) {
+  const state = loadAutopilotState();
+  return (state.history || []).slice(-limit);
+}
+
+module.exports = {
+  // Core functions
+  analyzeGitState,
+  enable,
+  disable,
+  getStatus,
+
+  // Suggestion management
+  acceptSuggestion,
+  dismissSuggestion,
+  clearSuggestions,
+
+  // Event mapping
+  addEventMapping,
+  removeEventMapping,
+
+  // Watcher
+  startWatcher,
+  stopWatcher,
+  pollGitState,
+
+  // Git hooks
+  installGitHooks,
+  removeGitHooks,
+  onGitHook,
+
+  // Configuration
+  loadConfig,
+  updateConfig,
+  loadAutopilotState,
+
+  // Events
+  getEmitter,
+
+  // History
+  getHistory,
+
+  // Constants
+  EVENT_WORKFLOWS,
+  DEFAULT_CONFIG
+};