@girardmedia/bootspring 1.2.0 → 2.0.3

package/mcp/response-formatter.js

@@ -70,6 +70,28 @@ function error(message, suggestions = []) {
   };
 }
 
+/**
+ * Format a warning response
+ * @param {string} message - Warning message
+ * @param {string[]} [suggestions] - Helpful suggestions
+ * @returns {object} MCP-formatted warning response
+ */
+function warning(message, suggestions = []) {
+  const sections = [`⚠️ Warning: ${message}`];
+
+  if (suggestions.length > 0) {
+    sections.push('\n💡 Suggestions:');
+    suggestions.forEach(s => sections.push(`  • ${s}`));
+  }
+
+  return {
+    content: [{
+      type: 'text',
+      text: sections.join('\n')
+    }]
+  };
+}
+
 /**
  * Format a list response with items
  * @param {object} options - List options
@@ -631,6 +653,7 @@ function capabilitiesList(_capabilities) {
 module.exports = {
   success,
   error,
+  warning,
   list,
   agentDetails,
   skillDetails,

package/mcp/tools/assist-tool.js

@@ -69,12 +69,20 @@ function createHandler({ natural, contextDetector, memory, format }) {
     const memoryRecommendations = [];
     if (memory && parsed.action.type !== 'unknown') {
       try {
-        const rec = memory.getRecommendation(
+        // Map parsed action type to decision tracker type
+        const decisionType = mapActionToDecisionType(
           parsed.action.type,
-          parsed.entities.features[0] || parsed.action.parameters?.feature
+          parsed.entities
         );
-        if (rec.found) {
-          memoryRecommendations.push(rec);
+        const decisionContext = parsed.entities.features[0] ||
+          parsed.action.parameters?.feature ||
+          parsed.entities.subjects[0];
+
+        if (decisionType && decisionContext) {
+          const rec = memory.getRecommendation(decisionType, decisionContext);
+          if (rec && rec.found) {
+            memoryRecommendations.push(rec);
+          }
         }
       } catch {
         // Memory not available yet
@@ -98,6 +106,72 @@ function createHandler({ natural, contextDetector, memory, format }) {
   };
 }
 
+/**
+ * Map parsed action type to decision tracker DECISION_TYPES
+ * The parser uses action types like 'add_feature', 'analyze', etc.
+ * The decision tracker uses types like 'architecture', 'database', etc.
+ */
+function mapActionToDecisionType(actionType, entities) {
+  // Direct action type mappings
+  const actionTypeMap = {
+    'deploy': 'deployment',
+    'run_tests': 'testing',
+    'add_tests': 'testing',
+    'quality_check': 'testing',
+    'optimize': 'performance'
+  };
+
+  if (actionTypeMap[actionType]) {
+    return actionTypeMap[actionType];
+  }
+
+  // For feature-related actions, infer from the feature/subject
+  const featureTypeMap = {
+    'auth': 'security',
+    'security': 'security',
+    'database': 'database',
+    'api': 'api',
+    'ui': 'ui',
+    'testing': 'testing',
+    'payments': 'api',
+    'notifications': 'api',
+    'search': 'database',
+    'analytics': 'database',
+    'file-upload': 'api',
+    'ai': 'api'
+  };
+
+  // Check entities for type inference
+  if (entities.features && entities.features.length > 0) {
+    const feature = entities.features[0];
+    if (featureTypeMap[feature]) {
+      return featureTypeMap[feature];
+    }
+  }
+
+  if (entities.subjects && entities.subjects.length > 0) {
+    const subject = entities.subjects[0];
+    if (featureTypeMap[subject]) {
+      return featureTypeMap[subject];
+    }
+  }
+
+  // Default mappings for general action types
+  const defaultMappings = {
+    'add_feature': 'architecture',
+    'remove_feature': 'architecture',
+    'update_feature': 'architecture',
+    'invoke_agent': 'agent_selection',
+    'start_workflow': 'workflow_choice',
+    'find_skill': 'skill_usage',
+    'explain': 'architecture',
+    'analyze': 'architecture',
+    'generate': 'architecture'
+  };
+
+  return defaultMappings[actionType] || 'architecture';
+}
+
 /**
  * Build response based on analysis
  */

package/mcp/tools/autopilot-tool.js

@@ -0,0 +1,408 @@
+/**
+ * MCP Git Autopilot Tool Module
+ *
+ * Provides MCP interface for git autopilot functionality.
+ * Automatically triggers workflows based on git events.
+ *
+ * @package bootspring
+ * @module mcp/tools/autopilot-tool
+ */
+
+function getToolDefinition() {
+  return {
+    name: 'bootspring_autopilot',
+    description: 'Git Autopilot - automatically trigger workflows based on git events (commits, branches, merges, tags).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          enum: [
+            'status',
+            'enable',
+            'disable',
+            'analyze',
+            'accept',
+            'dismiss',
+            'clear',
+            'start-watcher',
+            'stop-watcher',
+            'add-mapping',
+            'remove-mapping',
+            'install-hooks',
+            'remove-hooks',
+            'config',
+            'history'
+          ],
+          description: 'Action to perform on autopilot'
+        },
+        workflow: {
+          type: 'string',
+          description: 'Workflow name (for accept/dismiss actions)'
+        },
+        pattern: {
+          type: 'string',
+          description: 'Event pattern for mapping (e.g., "branch:feature/*", "commit:feat:")'
+        },
+        autoStart: {
+          type: 'boolean',
+          description: 'Enable auto-start of workflows (for enable action)'
+        },
+        watchInterval: {
+          type: 'number',
+          description: 'Polling interval in milliseconds (for enable action)'
+        },
+        hooks: {
+          type: 'object',
+          properties: {
+            onBranchCreate: { type: 'boolean' },
+            onCommit: { type: 'boolean' },
+            onMerge: { type: 'boolean' },
+            onTag: { type: 'boolean' },
+            onFileChange: { type: 'boolean' }
+          },
+          description: 'Git event hooks configuration (for enable action)'
+        },
+        limit: {
+          type: 'number',
+          description: 'Limit for history entries (default: 50)'
+        }
+      },
+      required: ['action']
+    }
+  };
+}
+
+function createHandler({ format }) {
+  // Lazy load to avoid circular dependencies
+  let gitAutopilot = null;
+
+  function getAutopilot() {
+    if (!gitAutopilot) {
+      gitAutopilot = require('../../hooks/git-autopilot');
+    }
+    return gitAutopilot;
+  }
+
+  return async (args) => {
+    const {
+      action,
+      workflow,
+      pattern,
+      autoStart,
+      watchInterval,
+      hooks,
+      limit
+    } = args;
+
+    const autopilot = getAutopilot();
+
+    switch (action) {
+      case 'status': {
+        const status = autopilot.getStatus();
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              enabled: status.enabled,
+              watcherActive: status.watcherActive,
+              pendingSuggestions: status.pendingSuggestions,
+              suggestions: status.suggestions,
+              lastCheck: status.lastCheck,
+              config: {
+                autoStart: status.config.autoStart,
+                watchInterval: status.config.watchInterval,
+                hooks: status.config.hooks,
+                ignoreBranches: status.config.ignoreBranches
+              }
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'enable': {
+        const options = {};
+        if (autoStart !== undefined) options.autoStart = autoStart;
+        if (watchInterval !== undefined) options.watchInterval = watchInterval;
+        if (hooks !== undefined) options.hooks = hooks;
+
+        const result = autopilot.enable(options);
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              success: result.success,
+              message: 'Git Autopilot enabled',
+              config: {
+                enabled: result.config.enabled,
+                autoStart: result.config.autoStart,
+                watchInterval: result.config.watchInterval,
+                hooks: result.config.hooks
+              },
+              nextStep: 'Use action="start-watcher" to begin monitoring git events'
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'disable': {
+        const result = autopilot.disable();
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              success: result.success,
+              message: 'Git Autopilot disabled'
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'analyze': {
+        const analysis = autopilot.analyzeGitState({ force: true });
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              enabled: analysis.enabled,
+              branch: analysis.branch,
+              isNewBranch: analysis.isNewBranch,
+              mergeInfo: analysis.mergeInfo,
+              suggestions: analysis.suggestions.map(s => ({
+                workflow: s.workflow,
+                trigger: s.trigger,
+                triggerType: s.triggerType,
+                value: s.value,
+                confidence: s.confidence,
+                autoStartEligible: s.autoStartEligible
+              })),
+              autoStartEnabled: analysis.autoStartEnabled
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'accept': {
+        if (!workflow) {
+          throw new Error('Workflow name required for accept action');
+        }
+        const result = autopilot.acceptSuggestion(workflow);
+        if (!result.success) {
+          throw new Error(result.error || 'Failed to accept suggestion');
+        }
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              success: true,
+              workflow: result.workflow,
+              workflowStarted: result.startResult?.success,
+              currentPhase: result.startResult?.currentPhase
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'dismiss': {
+        if (!workflow) {
+          throw new Error('Workflow name required for dismiss action');
+        }
+        const result = autopilot.dismissSuggestion(workflow);
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              success: result.success,
+              workflow: result.workflow,
+              message: `Suggestion for ${workflow} dismissed`
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'clear': {
+        const result = autopilot.clearSuggestions();
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              success: result.success,
+              cleared: result.cleared,
+              message: `Cleared ${result.cleared} pending suggestions`
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'start-watcher': {
+        const result = autopilot.startWatcher();
+        if (!result.success) {
+          throw new Error(result.error || 'Failed to start watcher');
+        }
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              success: true,
+              message: result.message,
+              interval: result.interval,
+              note: 'Watcher is now monitoring git events and will suggest workflows based on activity'
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'stop-watcher': {
+        const result = autopilot.stopWatcher();
+        if (!result.success) {
+          throw new Error(result.error || 'Failed to stop watcher');
+        }
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              success: true,
+              message: result.message
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'add-mapping': {
+        if (!pattern) {
+          throw new Error('Pattern required (e.g., "branch:feature/*")');
+        }
+        if (!workflow) {
+          throw new Error('Workflow name required');
+        }
+
+        // Validate pattern format
+        const validPrefixes = ['branch:', 'commit:', 'files:', 'merge:', 'tag:'];
+        const hasValidPrefix = validPrefixes.some(p => pattern.startsWith(p));
+        if (!hasValidPrefix) {
+          throw new Error(`Invalid pattern format. Must start with: ${validPrefixes.join(', ')}`);
+        }
+
+        const result = autopilot.addEventMapping(pattern, workflow);
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              success: result.success,
+              pattern: result.pattern,
+              workflow: result.workflow,
+              message: `Added mapping: ${pattern} -> ${workflow}`
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'remove-mapping': {
+        if (!pattern) {
+          throw new Error('Pattern required');
+        }
+        const result = autopilot.removeEventMapping(pattern);
+        if (!result.success) {
+          throw new Error(result.error || 'Failed to remove mapping');
+        }
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              success: true,
+              pattern: result.pattern,
+              message: `Removed mapping for ${pattern}`
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'install-hooks': {
+        const result = autopilot.installGitHooks();
+        if (!result.success) {
+          throw new Error(result.error || 'Failed to install hooks');
+        }
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              success: true,
+              installed: result.installed,
+              skipped: result.skipped,
+              message: result.message,
+              note: 'Git hooks provide immediate response to git events without polling'
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'remove-hooks': {
+        const result = autopilot.removeGitHooks();
+        if (!result.success) {
+          throw new Error(result.error || 'Failed to remove hooks');
+        }
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              success: true,
+              removed: result.removed,
+              message: result.message
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'config': {
+        const state = autopilot.loadAutopilotState();
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              config: {
+                enabled: state.config.enabled,
+                autoStart: state.config.autoStart,
+                requireConfirmation: state.config.requireConfirmation,
+                watchInterval: state.config.watchInterval,
+                ignoreBranches: state.config.ignoreBranches,
+                ignorePatterns: state.config.ignorePatterns,
+                hooks: state.config.hooks,
+                allowedAutoStartWorkflows: state.config.allowedAutoStartWorkflows,
+                cooldownPeriod: state.config.cooldownPeriod
+              },
+              eventMappings: Object.entries(state.config.eventMapping || {}).map(([pattern, wf]) => ({
+                pattern,
+                workflow: wf
+              }))
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'history': {
+        const history = autopilot.getHistory(limit || 50);
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              count: history.length,
+              history: history.reverse() // Most recent first
+            }, null, 2)
+          }]
+        };
+      }
+
+      default:
+        return format.error(`Unknown action: ${action}`, [
+          'Valid actions: status, enable, disable, analyze, accept, dismiss, clear,',
+          'start-watcher, stop-watcher, add-mapping, remove-mapping,',
+          'install-hooks, remove-hooks, config, history'
+        ]);
+    }
+  };
+}
+
+module.exports = {
+  getToolDefinition,
+  createHandler
+};