@girardmedia/bootspring 1.1.0

package/mcp/registry.js

@@ -0,0 +1,213 @@
+/**
+ * MCP registry composition
+ * Central place for tool/resource definitions and handler wiring.
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+const config = require('../core/config');
+const context = require('../core/context');
+const todoModule = require('../cli/todo');
+const agentModule = require('../cli/agent');
+const generateModule = require('../cli/generate');
+const intelligence = require('../intelligence');
+const gitMemory = require('../intelligence/git-memory');
+const prdModule = require('../intelligence/prd');
+const quality = require('../quality');
+const skills = require('../skills');
+const entitlements = require('../core/entitlements');
+const telemetry = require('../core/telemetry');
+const capabilities = require('./capabilities');
+const format = require('./response-formatter');
+
+const agentTool = require('./tools/agent-tool');
+const capabilitiesTool = require('./tools/capabilities-tool');
+const contextTool = require('./tools/context-tool');
+const dashboardTool = require('./tools/dashboard-tool');
+const generateTool = require('./tools/generate-tool');
+const loopTool = require('./tools/loop-tool');
+const memoryTool = require('./tools/memory-tool');
+const orchestratorTool = require('./tools/orchestrator-tool');
+const pluginTool = require('./tools/plugin-tool');
+const qualityTool = require('./tools/quality-tool');
+const skillTool = require('./tools/skill-tool');
+const telemetryTool = require('./tools/telemetry-tool');
+const todoTool = require('./tools/todo-tool');
+
+const recommendations = intelligence.createRecommendationsEngine({
+  intelligence,
+  telemetry,
+  skills,
+  entitlements
+});
+
+function trackTelemetry(event, payload) {
+  try {
+    telemetry.emitEvent(event, payload);
+  } catch {
+    // Do not break MCP responses due to telemetry failures.
+  }
+}
+
+const TOOLS = [
+  contextTool.getToolDefinition(),
+  agentTool.getToolDefinition(),
+  todoTool.getToolDefinition(),
+  generateTool.getToolDefinition(),
+  skillTool.getToolDefinition(),
+  qualityTool.getToolDefinition(),
+  dashboardTool.getToolDefinition(),
+  pluginTool.getToolDefinition(),
+  capabilitiesTool.getToolDefinition(),
+  telemetryTool.getToolDefinition(),
+  orchestratorTool.getToolDefinition(),
+  loopTool.getToolDefinition(),
+  memoryTool.getToolDefinition()
+];
+
+const RESOURCES = [
+  {
+    uri: 'bootspring://context/project',
+    name: 'Project Context',
+    description: 'Current project context and configuration',
+    mimeType: 'application/json'
+  },
+  {
+    uri: 'bootspring://context/claude.md',
+    name: 'CLAUDE.md Content',
+    description: 'Generated AI context file',
+    mimeType: 'text/markdown'
+  },
+  {
+    uri: 'bootspring://context/todo.md',
+    name: 'Todo List',
+    description: 'Project todo list',
+    mimeType: 'text/markdown'
+  },
+  {
+    uri: 'bootspring://agents/list',
+    name: 'Agent List',
+    description: 'Available specialized agents',
+    mimeType: 'application/json'
+  }
+];
+
+const toolHandlers = {
+  bootspring_capabilities: capabilitiesTool.createHandler({ capabilities }),
+  bootspring_orchestrator: orchestratorTool.createHandler({
+    intelligence,
+    entitlements,
+    recommendations,
+    trackTelemetry,
+    format
+  }),
+  bootspring_context: contextTool.createHandler({
+    config,
+    context,
+    format
+  }),
+  bootspring_skill: skillTool.createHandler({
+    skills,
+    entitlements,
+    trackTelemetry
+  }),
+  bootspring_agent: agentTool.createHandler({
+    agentModule,
+    format
+  }),
+  bootspring_todo: todoTool.createHandler({
+    config,
+    todoModule,
+    format
+  }),
+  bootspring_quality: qualityTool.createHandler({
+    config,
+    quality,
+    format
+  }),
+  bootspring_generate: generateTool.createHandler({
+    config,
+    context,
+    generateModule
+  }),
+  bootspring_dashboard: dashboardTool.createHandler({ config }),
+  bootspring_plugin: pluginTool.createHandler({ config }),
+  bootspring_loop: loopTool.createHandler({
+    prdModule,
+    format
+  }),
+  bootspring_memory: memoryTool.createHandler({ gitMemory }),
+  bootspring_telemetry: telemetryTool.createHandler({ telemetry }),
+};
+
+const resourceHandlers = {
+  'bootspring://context/project': async () => {
+    const cfg = config.load();
+    const ctx = context.get({ config: cfg });
+    return {
+      contents: [{
+        uri: 'bootspring://context/project',
+        mimeType: 'application/json',
+        text: JSON.stringify(ctx, null, 2)
+      }]
+    };
+  },
+
+  'bootspring://context/claude.md': async () => {
+    const cfg = config.load();
+    const claudePath = path.join(cfg._projectRoot, cfg.paths?.context || 'CLAUDE.md');
+    let content = '';
+    if (fs.existsSync(claudePath)) {
+      content = fs.readFileSync(claudePath, 'utf-8');
+    }
+    return {
+      contents: [{
+        uri: 'bootspring://context/claude.md',
+        mimeType: 'text/markdown',
+        text: content
+      }]
+    };
+  },
+
+  'bootspring://context/todo.md': async () => {
+    const cfg = config.load();
+    const todoPath = path.join(cfg._projectRoot, cfg.paths?.todo || 'todo.md');
+    let content = '';
+    if (fs.existsSync(todoPath)) {
+      content = fs.readFileSync(todoPath, 'utf-8');
+    }
+    return {
+      contents: [{
+        uri: 'bootspring://context/todo.md',
+        mimeType: 'text/markdown',
+        text: content
+      }]
+    };
+  },
+
+  'bootspring://agents/list': async () => {
+    const agents = Object.entries(agentModule.AGENTS).map(([id, agent]) => ({
+      id,
+      name: agent.name,
+      category: agent.category,
+      description: agent.description,
+      expertise: agent.expertise
+    }));
+    return {
+      contents: [{
+        uri: 'bootspring://agents/list',
+        mimeType: 'application/json',
+        text: JSON.stringify(agents, null, 2)
+      }]
+    };
+  }
+};
+
+module.exports = {
+  TOOLS,
+  RESOURCES,
+  toolHandlers,
+  resourceHandlers,
+  trackTelemetry
+};

package/mcp/response-formatter.js

@@ -0,0 +1,462 @@
+/**
+ * Bootspring MCP Response Formatter
+ * Creates well-structured, human-friendly tool responses
+ *
+ * @package bootspring
+ * @module mcp
+ */
+
+/**
+ * Format a success response with structured output
+ * @param {object} options - Response options
+ * @param {string} options.summary - Brief summary of what happened
+ * @param {any} options.data - Main data payload
+ * @param {string[]} [options.hints] - Optional hints for next actions
+ * @param {object} [options.meta] - Optional metadata
+ * @returns {object} MCP-formatted response
+ */
+function success({ summary, data, hints = [], meta = {} }) {
+  const sections = [];
+
+  // Summary section
+  if (summary) {
+    sections.push(`✓ ${summary}`);
+  }
+
+  // Data section
+  if (data !== undefined && data !== null) {
+    if (typeof data === 'string') {
+      sections.push(data);
+    } else {
+      sections.push(JSON.stringify(data, null, 2));
+    }
+  }
+
+  // Hints section
+  if (hints.length > 0) {
+    sections.push('\n💡 Hints:');
+    hints.forEach(hint => sections.push(`  • ${hint}`));
+  }
+
+  return {
+    content: [{
+      type: 'text',
+      text: sections.join('\n')
+    }],
+    _meta: meta
+  };
+}
+
+/**
+ * Format an error response
+ * @param {string} message - Error message
+ * @param {string[]} [suggestions] - Helpful suggestions
+ * @returns {object} MCP-formatted error response
+ */
+function error(message, suggestions = []) {
+  const sections = [`✗ Error: ${message}`];
+
+  if (suggestions.length > 0) {
+    sections.push('\n💡 Suggestions:');
+    suggestions.forEach(s => sections.push(`  • ${s}`));
+  }
+
+  return {
+    content: [{
+      type: 'text',
+      text: sections.join('\n')
+    }],
+    isError: true
+  };
+}
+
+/**
+ * Format a list response with items
+ * @param {object} options - List options
+ * @param {string} options.title - List title
+ * @param {any[]} options.items - Items to list
+ * @param {function} options.formatter - Function to format each item
+ * @param {string} [options.emptyMessage] - Message when list is empty
+ * @param {string[]} [options.hints] - Optional hints
+ * @returns {object} MCP-formatted response
+ */
+function list({ title, items, formatter, emptyMessage = 'No items found', hints = [] }) {
+  const sections = [];
+
+  sections.push(`📋 ${title}`);
+  sections.push(`   ${items.length} item(s)\n`);
+
+  if (items.length === 0) {
+    sections.push(`   ${emptyMessage}`);
+  } else {
+    items.forEach((item, index) => {
+      const formatted = formatter ? formatter(item, index) : String(item);
+      sections.push(formatted);
+    });
+  }
+
+  if (hints.length > 0) {
+    sections.push('\n💡 Hints:');
+    hints.forEach(hint => sections.push(`  • ${hint}`));
+  }
+
+  return {
+    content: [{
+      type: 'text',
+      text: sections.join('\n')
+    }]
+  };
+}
+
+/**
+ * Format agent details for display
+ * @param {string} id - Agent ID
+ * @param {object} agent - Agent data
+ * @returns {object} MCP-formatted response
+ */
+function agentDetails(id, agent) {
+  const sections = [
+    `🤖 Agent: ${agent.name}`,
+    `   ID: ${id}`,
+    `   Category: ${agent.category || 'General'}`,
+    '',
+    agent.description,
+    '',
+    '📚 Expertise:',
+    ...agent.expertise.map(e => `   • ${e}`),
+    ''
+  ];
+
+  if (agent.systemPrompt) {
+    sections.push('📝 System Prompt Available: Yes');
+  }
+
+  sections.push(
+    '',
+    '💡 Usage:',
+    '   Invoke this agent with a topic to get specialized assistance'
+  );
+
+  return {
+    content: [{
+      type: 'text',
+      text: sections.join('\n')
+    }]
+  };
+}
+
+/**
+ * Format skill details for display
+ * @param {string} id - Skill ID
+ * @param {object} skill - Skill data
+ * @param {string} [content] - Skill content (markdown)
+ * @returns {object} MCP-formatted response
+ */
+function skillDetails(id, skill, content = null) {
+  const sections = [
+    `📖 Skill: ${skill.name}`,
+    `   ID: ${id}`,
+    '',
+    skill.description,
+    ''
+  ];
+
+  if (skill.tags && skill.tags.length > 0) {
+    sections.push(`🏷️  Tags: ${skill.tags.join(', ')}`);
+    sections.push('');
+  }
+
+  if (content) {
+    sections.push('---', '', content);
+  }
+
+  return {
+    content: [{
+      type: 'text',
+      text: sections.join('\n')
+    }]
+  };
+}
+
+/**
+ * Format todo list for display
+ * @param {object[]} pending - Pending todos
+ * @param {object[]} completed - Completed todos
+ * @returns {object} MCP-formatted response
+ */
+function todoList(pending, completed) {
+  const sections = [
+    '📋 Project Todo List',
+    ''
+  ];
+
+  sections.push(`⏳ Pending (${pending.length}):`);
+  if (pending.length === 0) {
+    sections.push('   No pending tasks! 🎉');
+  } else {
+    pending.forEach((t, i) => {
+      sections.push(`   ${i}. [ ] ${t.text}`);
+    });
+  }
+
+  sections.push('');
+  sections.push(`✅ Completed (${completed.length}):`);
+  if (completed.length === 0) {
+    sections.push('   No completed tasks yet');
+  } else {
+    completed.slice(0, 5).forEach(t => {
+      sections.push(`   [x] ${t.text}`);
+    });
+    if (completed.length > 5) {
+      sections.push(`   ... and ${completed.length - 5} more`);
+    }
+  }
+
+  sections.push(
+    '',
+    '💡 Actions:',
+    '   • Add: bootspring_todo action=add text="your task"',
+    '   • Complete: bootspring_todo action=done index=0',
+    '   • Remove: bootspring_todo action=remove index=0'
+  );
+
+  return {
+    content: [{
+      type: 'text',
+      text: sections.join('\n')
+    }]
+  };
+}
+
+/**
+ * Format quality gate results
+ * @param {object} results - Gate execution results
+ * @returns {object} MCP-formatted response
+ */
+function qualityResults(results) {
+  const statusIcon = results.status === 'pass' ? '✅' : '❌';
+  const sections = [
+    `${statusIcon} Quality Gate: ${results.name || results.gate}`,
+    `   Status: ${results.status.toUpperCase()}`,
+    `   Passed: ${results.passed} | Failed: ${results.failed} | Skipped: ${results.skipped || 0}`,
+    ''
+  ];
+
+  sections.push('📊 Check Results:');
+  for (const check of results.results) {
+    const icon = check.status === 'pass'
+      ? '✓'
+      : check.status === 'fail'
+        ? '✗'
+        : '○';
+    sections.push(`   ${icon} ${check.name}: ${check.status}`);
+    if (check.status === 'fail' && check.message) {
+      const shortMessage = check.message.split('\n')[0].slice(0, 60);
+      sections.push(`      ${shortMessage}...`);
+    }
+  }
+
+  if (results.status === 'fail') {
+    sections.push(
+      '',
+      '💡 Next Steps:',
+      '   • Fix the failing checks and re-run the gate',
+      '   • Use --skip <check> to skip specific checks if needed'
+    );
+  }
+
+  return {
+    content: [{
+      type: 'text',
+      text: sections.join('\n')
+    }]
+  };
+}
+
+/**
+ * Format context validation results
+ * @param {object} validation - Validation results
+ * @returns {object} MCP-formatted response
+ */
+function contextValidation(validation) {
+  const statusIcon = validation.valid ? '✅' : '⚠️';
+  const sections = [
+    `${statusIcon} Project Validation`,
+    `   Valid: ${validation.valid}`,
+    ''
+  ];
+
+  if (validation.errors && validation.errors.length > 0) {
+    sections.push('❌ Errors:');
+    validation.errors.forEach(e => sections.push(`   • ${e}`));
+    sections.push('');
+  }
+
+  if (validation.warnings && validation.warnings.length > 0) {
+    sections.push('⚠️  Warnings:');
+    validation.warnings.forEach(w => sections.push(`   • ${w}`));
+    sections.push('');
+  }
+
+  if (validation.suggestions && validation.suggestions.length > 0) {
+    sections.push('💡 Suggestions:');
+    validation.suggestions.forEach(s => sections.push(`   • ${s}`));
+  }
+
+  return {
+    content: [{
+      type: 'text',
+      text: sections.join('\n')
+    }]
+  };
+}
+
+/**
+ * Format project context summary
+ * @param {object} ctx - Project context
+ * @returns {object} MCP-formatted response
+ */
+function contextSummary(ctx) {
+  const sections = [
+    `📁 Project: ${ctx.project?.name || 'Unknown'}`,
+    `   Version: ${ctx.project?.version || 'N/A'}`,
+    ''
+  ];
+
+  if (ctx.stack) {
+    sections.push('🛠️  Tech Stack:');
+    if (ctx.stack.framework) sections.push(`   Framework: ${ctx.stack.framework}`);
+    if (ctx.stack.language) sections.push(`   Language: ${ctx.stack.language}`);
+    if (ctx.stack.database) sections.push(`   Database: ${ctx.stack.database}`);
+    sections.push('');
+  }
+
+  if (ctx.plugins && Object.keys(ctx.plugins).length > 0) {
+    sections.push('🔌 Active Plugins:');
+    Object.keys(ctx.plugins).forEach(p => {
+      sections.push(`   • ${p}`);
+    });
+    sections.push('');
+  }
+
+  sections.push(
+    '💡 Commands:',
+    '   • bootspring_context action=validate - Check project health',
+    '   • bootspring_generate - Regenerate CLAUDE.md',
+    '   • bootspring_agent action=list - See available agents'
+  );
+
+  return {
+    content: [{
+      type: 'text',
+      text: sections.join('\n')
+    }]
+  };
+}
+
+/**
+ * Format orchestrator status
+ * @param {object} status - Orchestrator status
+ * @returns {object} MCP-formatted response
+ */
+function orchestratorStatus(status) {
+  const sections = [
+    '🎯 Orchestrator Status',
+    '',
+    `   Phase: ${status.currentPhase || 'Unknown'}`,
+    `   Available Agents: ${status.availableAgents || 0}`,
+    `   Active Workflow: ${status.activeWorkflow || 'None'}`,
+    ''
+  ];
+
+  if (status.activeWorkflowSignalProgress) {
+    sections.push(
+      `   Checkpoint Signals: ${status.activeWorkflowSignalProgress.completedSignals.length}/${status.activeWorkflowSignalProgress.totalSignals}`,
+      ''
+    );
+  }
+
+  if (status.recentSuggestions && status.recentSuggestions.length > 0) {
+    sections.push('💡 Recent Suggestions:');
+    status.recentSuggestions.forEach(s => {
+      sections.push(`   • ${s.text || s}`);
+    });
+  }
+
+  return {
+    content: [{
+      type: 'text',
+      text: sections.join('\n')
+    }]
+  };
+}
+
+/**
+ * Format PRD/loop status
+ * @param {object} prd - PRD data
+ * @param {object} progress - Progress info
+ * @returns {object} MCP-formatted response
+ */
+function loopStatus(prd, progress) {
+  const sections = [
+    `📋 PRD: ${prd.name}`,
+    '',
+    `   Progress: ${progress.completed}/${progress.total} stories (${Math.round(progress.percentage)}%)`,
+    ''
+  ];
+
+  const progressBar = generateProgressBar(progress.percentage);
+  sections.push(`   ${progressBar}`);
+  sections.push('');
+
+  sections.push('📖 Stories:');
+  prd.stories.forEach(s => {
+    const icon = s.status === 'complete'
+      ? '✅'
+      : s.status === 'in-progress'
+        ? '🔄'
+        : '⏳';
+    sections.push(`   ${icon} ${s.title} (${s.status})`);
+  });
+
+  sections.push(
+    '',
+    '💡 Actions:',
+    '   • bootspring_loop action=next - Get next story to work on',
+    '   • bootspring_loop action=complete storyId=X - Mark story complete'
+  );
+
+  return {
+    content: [{
+      type: 'text',
+      text: sections.join('\n')
+    }]
+  };
+}
+
+/**
+ * Generate a simple progress bar
+ * @param {number} percentage - Progress percentage (0-100)
+ * @returns {string}
+ */
+function generateProgressBar(percentage) {
+  const width = 20;
+  const filled = Math.round((percentage / 100) * width);
+  const empty = width - filled;
+  return '[' + '█'.repeat(filled) + '░'.repeat(empty) + '] ' + Math.round(percentage) + '%';
+}
+
+module.exports = {
+  success,
+  error,
+  list,
+  agentDetails,
+  skillDetails,
+  todoList,
+  qualityResults,
+  contextValidation,
+  contextSummary,
+  orchestratorStatus,
+  loopStatus,
+  generateProgressBar
+};