@girardmedia/bootspring 1.1.0

package/mcp/tools/memory-tool.js

@@ -0,0 +1,180 @@
+/**
+ * MCP memory tool module
+ */
+
+function getToolDefinition() {
+  return {
+    name: 'bootspring_memory',
+    description: 'Access git-based project memory. Extract learnings, search history, get file-specific context.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          enum: ['summary', 'search', 'files', 'stats'],
+          description: 'Action: summary (categorized learnings), search (by keyword), files (for specific files), stats (repo overview)'
+        },
+        query: {
+          type: 'string',
+          description: 'Search query (for search action)'
+        },
+        files: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'File paths to get learnings for (for files action)'
+        },
+        limit: {
+          type: 'number',
+          description: 'Max learnings to return (default: 20)'
+        }
+      },
+      required: ['action']
+    }
+  };
+}
+
+function createHandler({ gitMemory }) {
+  return async (args) => {
+    const { action, query, files, limit = 20 } = args;
+
+    if (!gitMemory.isGitRepo()) {
+      return {
+        content: [{
+          type: 'text',
+          text: JSON.stringify({
+            error: 'Not a git repository',
+            hint: 'Initialize git with: git init'
+          }, null, 2)
+        }]
+      };
+    }
+
+    switch (action) {
+      case 'summary': {
+        const result = gitMemory.extractLearnings({ limit });
+        if (result.error) {
+          return {
+            content: [{ type: 'text', text: `Error: ${result.error}` }]
+          };
+        }
+        const grouped = gitMemory.groupByCategory(result.learnings);
+        const summary = {};
+
+        for (const [category, items] of Object.entries(grouped)) {
+          const config = gitMemory.MEMORY_CATEGORIES[category];
+          summary[category] = {
+            icon: config?.icon || '📝',
+            label: config?.label || category,
+            count: items.length,
+            top: items.slice(0, 3).map(i => ({
+              hash: i.hash,
+              summary: i.summary
+            }))
+          };
+        }
+
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              totalLearnings: result.learnings.length,
+              categories: summary
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'search': {
+        if (!query) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({ error: 'query required for search' }, null, 2)
+            }]
+          };
+        }
+        const result = gitMemory.extractLearnings({ limit: 100 });
+        const matches = gitMemory.searchLearnings(result.learnings, query);
+
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              query,
+              matches: matches.slice(0, limit).map(m => ({
+                hash: m.hash,
+                summary: m.summary,
+                categories: m.categories,
+                details: m.details?.slice(0, 200)
+              }))
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'files': {
+        if (!files || files.length === 0) {
+          return {
+            content: [{
+              type: 'text',
+              text: JSON.stringify({ error: 'files array required' }, null, 2)
+            }]
+          };
+        }
+        const learnings = gitMemory.getLearningsForFiles(files, { limit });
+
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              files,
+              learnings: learnings.map(l => ({
+                hash: l.hash,
+                file: l.file,
+                summary: l.summary,
+                categories: l.categories
+              }))
+            }, null, 2)
+          }]
+        };
+      }
+
+      case 'stats': {
+        const stats = gitMemory.getRepoStats();
+        const result = gitMemory.extractLearnings({ limit: 100 });
+        const grouped = gitMemory.groupByCategory(result.learnings);
+
+        const categoryCounts = {};
+        for (const [cat, items] of Object.entries(grouped)) {
+          categoryCounts[cat] = items.length;
+        }
+
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              ...stats,
+              categoryCounts
+            }, null, 2)
+          }]
+        };
+      }
+
+      default:
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              error: `Unknown action: ${action}`,
+              validActions: ['summary', 'search', 'files', 'stats']
+            }, null, 2)
+          }]
+        };
+    }
+  };
+}
+
+module.exports = {
+  getToolDefinition,
+  createHandler
+};

package/mcp/tools/orchestrator-tool.js

@@ -0,0 +1,232 @@
+/**
+ * MCP orchestrator tool module
+ */
+
+const MAX_RECOMMENDATION_LIMIT = 50;
+const DEFAULT_RECOMMENDATION_LIMIT = 5;
+
+function getToolDefinition() {
+  return {
+    name: 'bootspring_orchestrator',
+    description: 'Intelligent agent coordination. Analyze context, suggest agents, manage workflows.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          enum: ['analyze', 'suggest', 'recommend', 'workflows', 'workflow', 'start', 'next', 'checkpoint', 'status'],
+          description: 'Action: analyze context, suggest agents, recommend workflows/skills, list workflows, show workflow, start/advance workflow, or status'
+        },
+        context: {
+          type: 'string',
+          description: 'Context text to analyze (for analyze/suggest actions)'
+        },
+        workflow: {
+          type: 'string',
+          description: 'Workflow name (for workflow action)'
+        },
+        signal: {
+          type: 'string',
+          description: 'Completion signal ref for action=checkpoint (exact text, partial text, or 1-based index)'
+        },
+        limit: {
+          type: 'number',
+          description: 'Max recommendations to return for action=recommend (default: 5)'
+        },
+        mode: {
+          type: 'string',
+          enum: ['local', 'server'],
+          description: 'Optional entitlement mode override'
+        },
+        entitled: {
+          type: 'boolean',
+          description: 'Optional entitlement override for premium workflows'
+        },
+        tier: {
+          type: 'string',
+          description: 'Optional tier override: free, pro, team, enterprise'
+        }
+      },
+      required: ['action']
+    }
+  };
+}
+
+function createHandler({ intelligence, entitlements, recommendations, trackTelemetry, format }) {
+  return async (args) => {
+    const {
+      action,
+      context: contextText,
+      workflow: workflowName,
+      signal,
+      mode,
+      entitled,
+      tier
+    } = args;
+    const accessOptions = { mode, entitled, tier };
+
+    switch (action) {
+      case 'analyze':
+      case 'suggest': {
+        const analysis = intelligence.analyzeContext(contextText || '');
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              phase: analysis.phase,
+              phaseName: analysis.phaseConfig?.name,
+              suggestions: analysis.suggestions,
+              skills: analysis.skills
+            }, null, 2)
+          }]
+        };
+      }
+      case 'recommend': {
+        const requestedLimit = Number(args.limit);
+        const validLimit = Number.isFinite(requestedLimit) && requestedLimit > 0
+          ? Math.min(requestedLimit, MAX_RECOMMENDATION_LIMIT)
+          : DEFAULT_RECOMMENDATION_LIMIT;
+        const result = recommendations.recommend({
+          contextText: contextText || '',
+          limit: validLimit,
+          accessOptions
+        });
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(result, null, 2)
+          }]
+        };
+      }
+      case 'workflows': {
+        const workflows = intelligence.listWorkflows();
+        const filtered = entitlements.filterAccessibleWorkflows(workflows, accessOptions);
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              workflows: filtered.allowed,
+              hiddenCount: filtered.denied.length
+            }, null, 2)
+          }]
+        };
+      }
+      case 'workflow': {
+        if (!workflowName) throw new Error('Workflow name required');
+        const workflow = intelligence.getWorkflow(workflowName);
+        if (!workflow) throw new Error(`Unknown workflow: ${workflowName}`);
+        const decision = entitlements.checkWorkflowAccess(workflow, accessOptions);
+        if (!decision.allowed) {
+          trackTelemetry('premium_prompted', {
+            capability: 'workflow_pack',
+            workflow: workflowName,
+            tier: workflow.tier || 'free',
+            mode: decision.context?.mode,
+            userTier: decision.context?.tier,
+            reason: decision.code
+          });
+          throw new Error(decision.reason);
+        }
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(workflow, null, 2)
+          }]
+        };
+      }
+      case 'start': {
+        if (!workflowName) throw new Error('Workflow name required');
+        const workflow = intelligence.getWorkflow(workflowName);
+        if (!workflow) throw new Error(`Unknown workflow: ${workflowName}`);
+        const decision = entitlements.checkWorkflowAccess(workflow, accessOptions);
+        if (!decision.allowed) {
+          trackTelemetry('premium_prompted', {
+            capability: 'workflow_pack',
+            workflow: workflowName,
+            tier: workflow.tier || 'free',
+            mode: decision.context?.mode,
+            userTier: decision.context?.tier,
+            reason: decision.code
+          });
+          throw new Error(decision.reason);
+        }
+        const result = intelligence.startWorkflow(workflowName);
+        if (!result.success) throw new Error(result.error || 'Failed to start workflow');
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              ...result,
+              signalProgress: intelligence.getWorkflowSignalProgress(workflowName)
+            }, null, 2)
+          }]
+        };
+      }
+      case 'next': {
+        const result = intelligence.advanceWorkflow();
+        if (!result.success) throw new Error(result.error || 'Failed to advance workflow');
+        const activeName = intelligence.loadState().activeWorkflow;
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              ...result,
+              signalProgress: activeName ? intelligence.getWorkflowSignalProgress(activeName) : null
+            }, null, 2)
+          }]
+        };
+      }
+      case 'checkpoint': {
+        const targetWorkflowName = workflowName || intelligence.loadState().activeWorkflow;
+        if (targetWorkflowName) {
+          const workflow = intelligence.getWorkflow(targetWorkflowName);
+          if (!workflow) throw new Error(`Unknown workflow: ${targetWorkflowName}`);
+          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
+            });
+            throw new Error(decision.reason);
+          }
+        }
+        const result = intelligence.markWorkflowCheckpoint(workflowName, signal);
+        if (!result.success) throw new Error(result.error || 'Failed to mark workflow checkpoint');
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(result, null, 2)
+          }]
+        };
+      }
+      case 'status': {
+        const state = intelligence.loadState();
+        const phase = intelligence.getCurrentPhase();
+        const agents = intelligence.getAvailableAgents();
+        return format.orchestratorStatus({
+          currentPhase: phase,
+          lastAnalysis: state.lastAnalysis,
+          activeWorkflow: state.activeWorkflow,
+          availableAgents: agents.length,
+          recentSuggestions: state.suggestions?.slice(0, 5),
+          activeWorkflowSignalProgress: state.activeWorkflow
+            ? intelligence.getWorkflowSignalProgress(state.activeWorkflow, state)
+            : null
+        });
+      }
+      default:
+        return format.error(`Unknown action: ${action}`, [
+          'Valid actions: analyze, suggest, recommend, workflows, workflow, start, next, checkpoint, status'
+        ]);
+    }
+  };
+}
+
+module.exports = {
+  getToolDefinition,
+  createHandler
+};

package/mcp/tools/plugin-tool.js

@@ -0,0 +1,76 @@
+/**
+ * MCP plugin tool module
+ */
+
+function getToolDefinition() {
+  return {
+    name: 'bootspring_plugin',
+    description: 'Manage plugins. List, enable, disable, or show plugin details.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          enum: ['list', 'show', 'enable', 'disable'],
+          description: 'Action: list, show, enable, or disable'
+        },
+        name: {
+          type: 'string',
+          description: 'Plugin name (e.g., auth, payments, database)'
+        }
+      },
+      required: ['action']
+    }
+  };
+}
+
+function createHandler({ config }) {
+  return async (args) => {
+    const { action, name } = args;
+    const cfg = config.load();
+
+    switch (action) {
+      case 'list': {
+        const plugins = Object.entries(cfg.plugins || {}).map(([id, plugin]) => ({
+          id,
+          enabled: plugin.enabled !== false,
+          provider: plugin.provider || 'default'
+        }));
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify(plugins, null, 2)
+          }]
+        };
+      }
+      case 'show': {
+        if (!name) throw new Error('Plugin name required');
+        const plugin = cfg.plugins?.[name];
+        if (!plugin) throw new Error(`Plugin not found: ${name}`);
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({ id: name, ...plugin }, null, 2)
+          }]
+        };
+      }
+      case 'enable':
+      case 'disable': {
+        if (!name) throw new Error('Plugin name required');
+        return {
+          content: [{
+            type: 'text',
+            text: `Plugin ${name} ${action}d. Update bootspring.config.js to persist.`
+          }]
+        };
+      }
+      default:
+        throw new Error(`Unknown action: ${action}`);
+    }
+  };
+}
+
+module.exports = {
+  getToolDefinition,
+  createHandler
+};

package/mcp/tools/quality-tool.js

@@ -0,0 +1,47 @@
+/**
+ * MCP quality tool module
+ */
+
+function getToolDefinition() {
+  return {
+    name: 'bootspring_quality',
+    description: 'Run quality gates to check code quality and security.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        gate: {
+          type: 'string',
+          enum: ['pre-commit', 'pre-push', 'pre-deploy'],
+          description: 'Quality gate to run'
+        }
+      },
+      required: ['gate']
+    }
+  };
+}
+
+function createHandler({ config, quality, format }) {
+  return async (args) => {
+    const { gate } = args;
+    const cfg = config.load();
+    const projectRoot = cfg._projectRoot;
+
+    const availableGates = quality.listGates();
+    if (!availableGates.includes(gate)) {
+      return format.error(`Unknown gate: ${gate}`, [
+        `Available gates: ${availableGates.join(', ')}`
+      ]);
+    }
+
+    const results = quality.runGate(gate, projectRoot, {
+      verbose: false
+    });
+
+    return format.qualityResults(results);
+  };
+}
+
+module.exports = {
+  getToolDefinition,
+  createHandler
+};