@girardmedia/bootspring 1.2.0 → 2.0.3

package/mcp/registry.js

@@ -15,12 +15,54 @@ 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');
+
+// Thin client: skills module may not exist locally
+// Skills are now served from the API
+let skills;
+try {
+  skills = require('../skills');
+} catch {
+  // Stub for thin client - skills fetched from API
+  skills = {
+    listSkills: () => [],
+    getSkillMetadata: () => null,
+    loadSkill: () => null,
+    searchSkills: () => [],
+    getCategories: () => [],
+    hasExternalSkillLibrary: () => false
+  };
+}
 const telemetry = require('../core/telemetry');
 const capabilities = require('./capabilities');
 const format = require('./response-formatter');
 
+// Seed system modules (lazy loaded)
+let seedModule = null;
+let ingestModule = null;
+let scaffoldModule = null;
+let mvpModule = null;
+
+function getSeedModule() {
+  if (!seedModule) seedModule = require('../cli/seed');
+  return seedModule;
+}
+
+function getIngestModule() {
+  if (!ingestModule) ingestModule = require('../core/ingest');
+  return ingestModule;
+}
+
+function getScaffoldModule() {
+  if (!scaffoldModule) scaffoldModule = require('../core/scaffold');
+  return scaffoldModule;
+}
+
+function getMvpModule() {
+  if (!mvpModule) mvpModule = require('../core/mvp');
+  return mvpModule;
+}
+
 const agentTool = require('./tools/agent-tool');
 const assistTool = require('./tools/assist-tool');
 const capabilitiesTool = require('./tools/capabilities-tool');
@@ -35,6 +77,12 @@ 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 seedTool = require('./tools/seed-tool');
+const mvpTool = require('./tools/mvp-tool');
+const prdTool = require('./tools/prd-tool');
+const autopilotTool = require('./tools/autopilot-tool');
+const contentTool = require('./tools/content-tool');
+const suggestTool = require('./tools/suggest-tool');
 
 // Natural language and context detection
 const natural = require('../natural');
@@ -69,7 +117,13 @@ const TOOLS = [
   telemetryTool.getToolDefinition(),
   orchestratorTool.getToolDefinition(),
   loopTool.getToolDefinition(),
-  memoryTool.getToolDefinition()
+  memoryTool.getToolDefinition(),
+  seedTool.getToolDefinition(),
+  mvpTool.getToolDefinition(),
+  prdTool.getToolDefinition(),
+  autopilotTool.getToolDefinition(),
+  contentTool.getToolDefinition(),
+  suggestTool.getToolDefinition()
 ];
 
 const RESOURCES = [
@@ -96,6 +150,36 @@ const RESOURCES = [
     name: 'Agent List',
     description: 'Available specialized agents',
     mimeType: 'application/json'
+  },
+  {
+    uri: 'bootspring://workflow/status',
+    name: 'Workflow Status',
+    description: 'Current active workflow status and progress',
+    mimeType: 'application/json'
+  },
+  {
+    uri: 'bootspring://skills/catalog',
+    name: 'Skills Catalog',
+    description: 'Available skills and patterns catalog',
+    mimeType: 'application/json'
+  },
+  {
+    uri: 'bootspring://memory/recent',
+    name: 'Recent Memory',
+    description: 'Recent decisions and learning insights',
+    mimeType: 'application/json'
+  },
+  {
+    uri: 'bootspring://autopilot/status',
+    name: 'Git Autopilot Status',
+    description: 'Git autopilot status and pending workflow suggestions',
+    mimeType: 'application/json'
+  },
+  {
+    uri: 'bootspring://content/templates',
+    name: 'Content Templates',
+    description: 'Available document templates for content generation',
+    mimeType: 'application/json'
   }
 ];
 
@@ -152,6 +236,53 @@ const toolHandlers = {
   }),
   bootspring_memory: memoryTool.createHandler({ gitMemory }),
   bootspring_telemetry: telemetryTool.createHandler({ telemetry }),
+  bootspring_seed: seedTool.createHandler({
+    seedModule: { run: (args) => getSeedModule().run(args) },
+    ingestModule: {
+      ingestAll: (root) => getIngestModule().ingestAll(root),
+      generateDocuments: (ingested, seedConfig, root) => getIngestModule().generateDocuments(ingested, seedConfig, root),
+      updateContextIndex: (root, ingested) => getIngestModule().updateContextIndex(root, ingested),
+      ingestPRD: (root) => getIngestModule().ingestPRD(root)
+    },
+    scaffoldModule: {
+      getPresets: () => getScaffoldModule().getPresets(),
+      getPresetConfig: (preset) => getScaffoldModule().getPresetConfig(preset),
+      getPresetInfo: (preset) => getScaffoldModule().getPresetInfo(preset),
+      planScaffold: (cfg, root) => getScaffoldModule().planScaffold(cfg, root),
+      execute: (plan, root) => getScaffoldModule().execute(plan, root)
+    },
+    config,
+    format
+  }),
+  bootspring_mvp: mvpTool.createHandler({
+    mvpModule: {
+      MVP_STRUCTURE: { source: '.bootspring/inputs/mvp/source', references: '.bootspring/references' },
+      initMvpFolders: () => getMvpModule().initMvpFolders(),
+      analyzeMvp: () => getMvpModule().analyzeMvp(),
+      importMvp: (opts) => getMvpModule().importMvp(opts),
+      CODE_ISSUES: getMvpModule().CODE_ISSUES || {}
+    },
+    config,
+    format
+  }),
+  bootspring_prd: prdTool.createHandler({
+    ingestModule: {
+      ingestPRD: (root) => getIngestModule().ingestPRD(root)
+    },
+    todoModule,
+    config,
+    format
+  }),
+  bootspring_autopilot: autopilotTool.createHandler({ format }),
+  bootspring_content: contentTool.createHandler({
+    contentGen: intelligence.contentGen,
+    config,
+    format
+  }),
+  bootspring_suggest: suggestTool.createHandler({
+    config,
+    format
+  }),
 };
 
 const resourceHandlers = {
@@ -214,13 +345,559 @@ const resourceHandlers = {
         text: JSON.stringify(agents, null, 2)
       }]
     };
+  },
+
+  'bootspring://workflow/status': async () => {
+    const state = intelligence.loadState();
+    const currentPhase = intelligence.getCurrentPhase();
+    const phaseConfig = intelligence.PHASE_AGENTS[currentPhase];
+
+    let workflowInfo = null;
+    if (state.activeWorkflow) {
+      const workflow = intelligence.getWorkflow(state.activeWorkflow);
+      const progress = intelligence.getWorkflowSignalProgress(state.activeWorkflow, state);
+      workflowInfo = {
+        name: state.activeWorkflow,
+        step: state.workflowStep + 1,
+        totalSteps: workflow?.phases?.length || 0,
+        currentPhase: workflow?.phases?.[state.workflowStep]?.name || null,
+        progress: progress || null
+      };
+    }
+
+    return {
+      contents: [{
+        uri: 'bootspring://workflow/status',
+        mimeType: 'application/json',
+        text: JSON.stringify({
+          phase: currentPhase,
+          phaseName: phaseConfig?.name || 'Unknown',
+          activeWorkflow: workflowInfo,
+          availableWorkflows: intelligence.listWorkflows().map(w => ({
+            key: w.key,
+            name: w.name,
+            tier: w.tier
+          })),
+          lastAnalysis: state.lastAnalysis
+        }, null, 2)
+      }]
+    };
+  },
+
+  'bootspring://skills/catalog': async () => {
+    const allSkills = skills.listSkills({ includeExternal: true });
+    const catalog = allSkills.map(skillId => {
+      const metadata = skills.getSkillMetadata(skillId);
+      return {
+        id: skillId,
+        name: metadata?.name || skillId,
+        description: metadata?.description || '',
+        category: metadata?.category || 'general',
+        source: metadata?.source || 'built-in'
+      };
+    });
+
+    return {
+      contents: [{
+        uri: 'bootspring://skills/catalog',
+        mimeType: 'application/json',
+        text: JSON.stringify({
+          total: catalog.length,
+          skills: catalog
+        }, null, 2)
+      }]
+    };
+  },
+
+  'bootspring://memory/recent': async () => {
+    const memory = intelligence.memory;
+    let recentDecisions = [];
+    let stats = {};
+    let patterns = [];
+
+    try {
+      recentDecisions = memory.getRecentDecisions(10);
+      stats = memory.getStats();
+      patterns = memory.getPatterns().slice(0, 5);
+    } catch {
+      // Memory may not be initialized
+    }
+
+    return {
+      contents: [{
+        uri: 'bootspring://memory/recent',
+        mimeType: 'application/json',
+        text: JSON.stringify({
+          stats,
+          recentDecisions: recentDecisions.map(d => ({
+            id: d.id,
+            type: d.type,
+            decision: d.decision,
+            outcome: d.outcome?.status || 'pending',
+            timestamp: d.timestamp
+          })),
+          topPatterns: patterns
+        }, null, 2)
+      }]
+    };
+  },
+
+  'bootspring://autopilot/status': async () => {
+    let autopilotStatus = { enabled: false, suggestions: [] };
+
+    try {
+      const gitAutopilot = require('../hooks/git-autopilot');
+      autopilotStatus = gitAutopilot.getStatus();
+    } catch {
+      // Autopilot may not be available
+    }
+
+    return {
+      contents: [{
+        uri: 'bootspring://autopilot/status',
+        mimeType: 'application/json',
+        text: JSON.stringify({
+          enabled: autopilotStatus.enabled,
+          watcherActive: autopilotStatus.watcherActive || false,
+          pendingSuggestions: autopilotStatus.pendingSuggestions || 0,
+          suggestions: (autopilotStatus.suggestions || []).map(s => ({
+            workflow: s.workflow,
+            trigger: s.trigger,
+            triggerType: s.triggerType,
+            value: s.value,
+            confidence: s.confidence
+          })),
+          lastCheck: autopilotStatus.lastCheck
+        }, null, 2)
+      }]
+    };
+  },
+
+  'bootspring://content/templates': async () => {
+    const contentGen = intelligence.contentGen;
+    const templates = contentGen.listTemplates();
+    const categories = contentGen.getCategories();
+    const stats = contentGen.getStatistics();
+
+    // Group templates by category
+    const grouped = {};
+    for (const t of templates) {
+      if (!grouped[t.category]) {
+        grouped[t.category] = [];
+      }
+      grouped[t.category].push({
+        key: t.key,
+        name: t.name,
+        description: t.description,
+        sections: t.sections,
+        hasTemplateFile: t.hasTemplateFile,
+        compliance: t.compliance
+      });
+    }
+
+    return {
+      contents: [{
+        uri: 'bootspring://content/templates',
+        mimeType: 'application/json',
+        text: JSON.stringify({
+          total: templates.length,
+          categories,
+          byCategory: grouped,
+          statistics: {
+            totalGenerated: stats.totalGenerated,
+            lastGeneration: stats.lastGeneration
+          }
+        }, null, 2)
+      }]
+    };
   }
 };
 
+// ============================================================================
+// Tool Invocation System
+// ============================================================================
+// Provides tool-to-tool invocation with circular dependency prevention
+// and context passing between tools.
+// ============================================================================
+
+/**
+ * Active call stack for circular dependency detection.
+ * Uses AsyncLocalStorage for proper async context tracking.
+ */
+const { AsyncLocalStorage } = require('async_hooks');
+const toolCallContext = new AsyncLocalStorage();
+
+/**
+ * Maximum allowed tool call depth to prevent runaway recursion
+ */
+const MAX_CALL_DEPTH = 10;
+
+/**
+ * Create an invocation context for tracking tool calls
+ * @param {object} parentContext - Optional parent context
+ * @returns {object} New invocation context
+ */
+function createInvocationContext(parentContext = null) {
+  return {
+    callStack: parentContext?.callStack ? [...parentContext.callStack] : [],
+    depth: parentContext?.depth ?? 0,
+    startTime: Date.now(),
+    parentTool: parentContext?.currentTool || null,
+    currentTool: null,
+    sharedData: parentContext?.sharedData || {},
+    results: parentContext?.results || {}
+  };
+}
+
+/**
+ * Get the current invocation context
+ * @returns {object|null} Current context or null if not in a tool invocation
+ */
+function getCurrentContext() {
+  return toolCallContext.getStore() || null;
+}
+
+/**
+ * Check if invoking a tool would create a circular dependency
+ * @param {string} toolName - Tool to check
+ * @param {object} ctx - Current invocation context
+ * @returns {boolean} True if circular dependency detected
+ */
+function wouldCreateCircularDependency(toolName, ctx) {
+  if (!ctx || !ctx.callStack) return false;
+  return ctx.callStack.includes(toolName);
+}
+
+/**
+ * Invoke a tool from within another tool (tool chaining)
+ *
+ * Features:
+ * - Circular dependency prevention
+ * - Call depth limiting
+ * - Context passing between tools
+ * - Result caching within invocation chain
+ *
+ * @param {string} toolName - Name of the tool to invoke (e.g., 'bootspring_context')
+ * @param {object} args - Arguments to pass to the tool
+ * @param {object} options - Invocation options
+ * @param {boolean} options.allowCircular - Allow circular calls (default: false)
+ * @param {boolean} options.useCache - Use cached result if available (default: true)
+ * @param {object} options.context - Additional context to pass
+ * @returns {Promise<object>} Tool result
+ */
+async function invokeTool(toolName, args = {}, options = {}) {
+  const { allowCircular = false, useCache = true, context: additionalContext = {} } = options;
+
+  const handler = toolHandlers[toolName];
+
+  if (!handler) {
+    const available = Object.keys(toolHandlers).join(', ');
+    return {
+      error: true,
+      code: 'TOOL_NOT_FOUND',
+      message: `Tool not found: ${toolName}. Available: ${available}`,
+      tool: toolName
+    };
+  }
+
+  // Get or create invocation context
+  const parentCtx = getCurrentContext();
+  const ctx = createInvocationContext(parentCtx);
+  ctx.currentTool = toolName;
+
+  // Check for circular dependency
+  if (!allowCircular && wouldCreateCircularDependency(toolName, ctx)) {
+    return {
+      error: true,
+      code: 'CIRCULAR_DEPENDENCY',
+      message: `Circular dependency detected: ${ctx.callStack.join(' -> ')} -> ${toolName}`,
+      tool: toolName,
+      callStack: [...ctx.callStack, toolName]
+    };
+  }
+
+  // Check call depth
+  if (ctx.depth >= MAX_CALL_DEPTH) {
+    return {
+      error: true,
+      code: 'MAX_DEPTH_EXCEEDED',
+      message: `Maximum tool call depth (${MAX_CALL_DEPTH}) exceeded`,
+      tool: toolName,
+      depth: ctx.depth
+    };
+  }
+
+  // Check cache for identical calls
+  const cacheKey = `${toolName}:${JSON.stringify(args)}`;
+  if (useCache && ctx.results[cacheKey]) {
+    return {
+      ...ctx.results[cacheKey],
+      _cached: true
+    };
+  }
+
+  // Update context for this invocation
+  ctx.callStack.push(toolName);
+  ctx.depth++;
+
+  // Merge additional context into shared data
+  if (additionalContext) {
+    Object.assign(ctx.sharedData, additionalContext);
+  }
+
+  // Execute the tool within the context
+  try {
+    const result = await toolCallContext.run(ctx, async () => {
+      // Add invocation metadata to args if tool supports it
+      const enhancedArgs = {
+        ...args,
+        _invocation: {
+          caller: ctx.parentTool,
+          depth: ctx.depth,
+          sharedData: ctx.sharedData
+        }
+      };
+
+      return await handler(enhancedArgs);
+    });
+
+    // Cache the result
+    ctx.results[cacheKey] = result;
+
+    // Add metadata to result
+    return {
+      ...result,
+      _meta: {
+        tool: toolName,
+        depth: ctx.depth,
+        duration: Date.now() - ctx.startTime,
+        caller: ctx.parentTool
+      }
+    };
+  } catch (error) {
+    return {
+      error: true,
+      code: 'TOOL_ERROR',
+      message: error.message,
+      tool: toolName,
+      stack: error.stack,
+      caller: ctx.parentTool
+    };
+  }
+}
+
+/**
+ * Invoke multiple tools in sequence with context sharing
+ *
+ * Results from earlier tools are available to later tools via sharedData.
+ *
+ * @param {Array<{tool: string, args: object|function}>} toolCalls - Array of tool invocations
+ *   args can be a function (previousResults) => args for dynamic arguments
+ * @param {object} options - Options for the sequence
+ * @param {boolean} options.stopOnError - Stop sequence on first error (default: true)
+ * @param {object} options.initialContext - Initial shared context
+ * @returns {Promise<object>} Sequence result with all tool results
+ */
+async function invokeToolSequence(toolCalls, options = {}) {
+  const { stopOnError = true, initialContext = {} } = options;
+  const results = [];
+  const sharedData = { ...initialContext };
+
+  // Create a root context for the sequence
+  const rootCtx = createInvocationContext();
+  rootCtx.sharedData = sharedData;
+
+  for (let i = 0; i < toolCalls.length; i++) {
+    const call = toolCalls[i];
+    const { tool } = call;
+
+    // Support dynamic args based on previous results
+    let args = call.args || {};
+    if (typeof args === 'function') {
+      args = args(results, sharedData);
+    }
+
+    const result = await toolCallContext.run(rootCtx, async () => {
+      return await invokeTool(tool, args, { context: sharedData });
+    });
+
+    results.push({ tool, result, index: i });
+
+    // Store result in shared data for next tool
+    sharedData[`_result_${tool}`] = result;
+    sharedData._lastResult = result;
+
+    // Stop on error if configured
+    if (stopOnError && result.error) {
+      return {
+        success: false,
+        stoppedAt: i,
+        stoppedTool: tool,
+        error: result,
+        results,
+        sharedData
+      };
+    }
+  }
+
+  return {
+    success: true,
+    results,
+    sharedData
+  };
+}
+
+/**
+ * Invoke multiple tools in parallel
+ *
+ * All tools execute concurrently. Use when tools are independent.
+ *
+ * @param {Array<{tool: string, args: object}>} toolCalls - Array of tool invocations
+ * @param {object} options - Options for parallel execution
+ * @param {number} options.concurrency - Max concurrent calls (default: unlimited)
+ * @param {boolean} options.settleAll - Wait for all to complete even on errors (default: true)
+ * @returns {Promise<object>} Parallel result with all tool results
+ */
+async function invokeToolParallel(toolCalls, options = {}) {
+  const { concurrency = Infinity, settleAll = true } = options;
+
+  // Create root context for parallel execution
+  const rootCtx = createInvocationContext();
+
+  // Execute with concurrency limit
+  const executeWithLimit = async (calls, limit) => {
+    const results = [];
+    const executing = new Set();
+
+    for (const call of calls) {
+      const promise = toolCallContext.run(rootCtx, async () => {
+        const result = await invokeTool(call.tool, call.args || {});
+        return { tool: call.tool, result };
+      });
+
+      results.push(promise);
+      executing.add(promise);
+
+      // Remove from executing set when done
+      promise.finally(() => executing.delete(promise));
+
+      // Wait if at concurrency limit
+      if (executing.size >= limit) {
+        await Promise.race(executing);
+      }
+    }
+
+    return settleAll
+      ? Promise.allSettled(results)
+      : Promise.all(results);
+  };
+
+  const rawResults = await executeWithLimit(toolCalls, concurrency);
+
+  // Normalize results
+  const normalizedResults = rawResults.map((r, index) => {
+    if (r.status === 'fulfilled') {
+      return r.value;
+    } else {
+      return {
+        tool: toolCalls[index].tool,
+        result: {
+          error: true,
+          code: 'PARALLEL_ERROR',
+          message: r.reason?.message || 'Unknown error'
+        }
+      };
+    }
+  });
+
+  const errors = normalizedResults.filter(r => r.result?.error);
+
+  return {
+    success: errors.length === 0,
+    results: normalizedResults,
+    errors: errors.length > 0 ? errors : undefined
+  };
+}
+
+/**
+ * Create a tool invoker bound to specific context
+ *
+ * Useful for passing to tools that need to invoke other tools.
+ *
+ * @param {object} boundContext - Context to bind to all invocations
+ * @returns {object} Bound invoker with invokeTool, invokeSequence, invokeParallel
+ */
+function createBoundInvoker(boundContext = {}) {
+  return {
+    invoke: (toolName, args, options = {}) =>
+      invokeTool(toolName, args, { ...options, context: { ...boundContext, ...options.context } }),
+
+    sequence: (toolCalls, options = {}) =>
+      invokeToolSequence(toolCalls, { ...options, initialContext: { ...boundContext, ...options.initialContext } }),
+
+    parallel: (toolCalls, options) =>
+      invokeToolParallel(toolCalls, options),
+
+    // Convenience method to get a tool's result
+    get: async (toolName, args) => {
+      const result = await invokeTool(toolName, args, { context: boundContext });
+      return result.error ? null : result;
+    }
+  };
+}
+
+/**
+ * Get list of available tool names
+ * @returns {Array<string>} Tool names
+ */
+function getAvailableTools() {
+  return Object.keys(toolHandlers);
+}
+
+/**
+ * Check if a tool exists
+ * @param {string} toolName - Tool name to check
+ * @returns {boolean} True if tool exists
+ */
+function hasTool(toolName) {
+  return toolName in toolHandlers;
+}
+
+/**
+ * Get tool definition by name
+ * @param {string} toolName - Tool name
+ * @returns {object|null} Tool definition or null
+ */
+function getToolDefinition(toolName) {
+  const tool = TOOLS.find(t => t.name === toolName);
+  return tool || null;
+}
+
 module.exports = {
+  // Tool and resource definitions
   TOOLS,
   RESOURCES,
+
+  // Handlers
   toolHandlers,
   resourceHandlers,
-  trackTelemetry
+  trackTelemetry,
+
+  // Tool invocation system
+  invokeTool,
+  invokeToolSequence,
+  invokeToolParallel,
+  createBoundInvoker,
+
+  // Tool introspection
+  getAvailableTools,
+  hasTool,
+  getToolDefinition,
+
+  // Context utilities (for advanced use)
+  getCurrentContext,
+  createInvocationContext,
+
+  // Constants
+  MAX_CALL_DEPTH
 };