@girardmedia/bootspring 2.5.0 → 2.5.2

package/dist/mcp/index.d.ts

@@ -1 +1,357 @@
-export { A as AccessInfo, j as AgentData, k as AssistResponseData, B as BoundInvoker, l as BuildCapabilitiesOptions, C as CapabilitiesInfo, m as CapabilitiesManifest, n as ContextValidationResult, F as FilteredWorkflows, I as IntentDetectionData, o as InvocationContext, p as InvokeParallelOptions, q as InvokeSequenceOptions, r as InvokeToolOptions, s as InvokeToolResult, L as ListOptions, t as MAX_CALL_DEPTH, M as MCPCapabilities, a as MCPContent, b as MCPInputSchema, c as MCPPrompt, d as MCPPromptArgument, e as MCPPropertySchema, f as MCPResource, g as MCPTool, h as MCPToolResult, u as MCPToolResultWithMeta, O as OrchestratorStatus, P as PRDData, v as PackInfo, w as ParallelResult, x as PlatformInfo, y as PolicyInfo, z as PolicyProfile, D as ProgressInfo, E as ProjectContextDisplay, Q as QualityCheckResult, G as QualityGateResults, R as RESOURCES, H as ResourceDefinition, J as ResourceHandler, K as ResourceResponse, S as SequenceResult, N as SkillData, T as SkillsCapability, U as SuccessOptions, V as TOOLS, W as TelemetryCapability, X as TodoItem, Y as ToolCall, Z as ToolDefinition, _ as ToolHandler, $ as ToolSequenceResult, a0 as ValidationResult, a1 as WorkflowAccessContext, a2 as WorkflowDefinition, a3 as WorkflowsCapability, a4 as agentDetails, a5 as assistResponse, a6 as buildCapabilities, a7 as capabilitiesList, a8 as contextSummary, a9 as contextValidation, aa as createBoundInvoker, ab as createInvocationContext, ac as error, ad as generateProgressBar, ae as getAvailableTools, af as getCurrentContext, ag as getRegistry, ah as getToolDefinition, ai as hasTool, aj as intentDetection, ak as invokeTool, al as invokeToolParallel, am as invokeToolSequence, an as list, ao as loopStatus, ap as main, aq as orchestratorStatus, ar as qualityResults, as as resourceHandlers, at as skillDetails, au as success, av as todoList, aw as toolHandlers, ax as trackTelemetry, ay as validateDependencies, az as warning } from '../index-DvGc3BRk.js';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { ToolDefinition, ResourceDefinition, ToolHandler, ResourceHandler, InvokeToolOptions, InvokeToolResult, MCPToolResult, WorkflowDefinition, CapabilitiesManifest } from '@bootspring/types';
+export { InvocationContext, InvokeToolOptions, InvokeToolResult, ResourceDefinition, ResourceHandler, ToolDefinition, ToolHandler } from '@bootspring/types';
+
+/**
+ * Bootspring MCP Server
+ * Model Context Protocol server for AI assistant integration
+ *
+ * @package @bootspring/mcp
+ * @module server
+ */
+
+interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+interface RegistryExports {
+    TOOLS: ToolDefinition[];
+    RESOURCES: ResourceDefinition[];
+    toolHandlers: Record<string, ToolHandler>;
+    resourceHandlers: Record<string, ResourceHandler>;
+    trackTelemetry: (event: string, payload: Record<string, unknown>) => void;
+}
+interface MCPServerOptions {
+    name?: string;
+    version?: string;
+    registry: RegistryExports;
+    onToolSuccess?: (toolName: string) => void;
+}
+interface BootstrapModule {
+    getRegistry?: () => RegistryExports;
+    main?: () => Promise<void>;
+    default?: {
+        getRegistry?: () => RegistryExports;
+        main?: () => Promise<void>;
+    };
+}
+interface ResolveRuntimeRegistryOptions {
+    basePath?: string;
+    defaultRegistry?: RegistryExports;
+    loadModule?: (specifier: string) => Promise<BootstrapModule>;
+}
+declare function createServer(options: MCPServerOptions): Promise<Server>;
+declare function isRegistryPopulated(registry: RegistryExports): boolean;
+declare function getLegacyRegistryCandidatePaths(basePath?: string): string[];
+declare function resolveRuntimeRegistry(options?: ResolveRuntimeRegistryOptions): Promise<RegistryExports | null>;
+declare function startStdioServer(options: MCPServerOptions): Promise<void>;
+declare function validateDependencies(): ValidationResult;
+declare function main(): Promise<void>;
+
+/**
+ * MCP Registry
+ * Central registry for tool/resource definitions and handler wiring
+ *
+ * @package @bootspring/mcp
+ * @module registry
+ */
+
+type CompatibilityRegistry = ReturnType<typeof createRegistryExports>;
+interface LegacyRegistryModule {
+    TOOLS?: ToolDefinition[] | undefined;
+    RESOURCES?: ResourceDefinition[] | undefined;
+    toolHandlers?: Record<string, ToolHandler> | undefined;
+    resourceHandlers?: Record<string, ResourceHandler> | undefined;
+    trackTelemetry?: ((event: string, payload: Record<string, unknown>) => void) | undefined;
+    getRegistry?: (() => CompatibilityRegistry) | undefined;
+    getRegistryExports?: (() => CompatibilityRegistry) | undefined;
+    default?: LegacyRegistryModule | undefined;
+}
+interface CompatibilityRegistryOptions {
+    basePath?: string | undefined;
+    defaultRegistry?: CompatibilityRegistry | undefined;
+    loadModule?: ((candidatePath: string) => LegacyRegistryModule) | undefined;
+}
+/**
+ * Register a tool with the MCP server
+ */
+declare function registerTool(definition: ToolDefinition, handler: ToolHandler): void;
+/**
+ * Register a resource with the MCP server
+ */
+declare function registerResource(definition: ResourceDefinition, handler: ResourceHandler): void;
+/**
+ * Load tools from a directory of tool modules
+ */
+declare function loadToolsFromDirectory(toolsDir: string): void;
+/**
+ * Invoke a tool from within another tool (tool-to-tool calls)
+ */
+declare function invokeTool(toolName: string, args: Record<string, unknown>, options?: InvokeToolOptions): Promise<InvokeToolResult>;
+/**
+ * Track telemetry events
+ */
+declare function trackTelemetry(event: string, payload: Record<string, unknown>): void;
+declare function createRegistryExports(): {
+    TOOLS: ToolDefinition[];
+    RESOURCES: ResourceDefinition[];
+    toolHandlers: Record<string, ToolHandler>;
+    resourceHandlers: Record<string, ResourceHandler>;
+    trackTelemetry: typeof trackTelemetry;
+};
+declare function getCompatibilityRegistryCandidatePaths(basePath?: string): string[];
+declare function resolveCompatibilityRegistry(options?: CompatibilityRegistryOptions): CompatibilityRegistry;
+/**
+ * Clear the result cache
+ */
+declare function clearCache(): void;
+/**
+ * Get all registered tools
+ */
+declare function getTools(): ToolDefinition[];
+/**
+ * Get all registered resources
+ */
+declare function getResources(): ResourceDefinition[];
+/**
+ * Get all tool handlers
+ */
+declare function getToolHandlers(): Record<string, ToolHandler>;
+/**
+ * Get all resource handlers
+ */
+declare function getResourceHandlers(): Record<string, ResourceHandler>;
+/**
+ * Get the full registry export object
+ */
+declare function getRegistryExports(): {
+    TOOLS: ToolDefinition[];
+    RESOURCES: ResourceDefinition[];
+    toolHandlers: Record<string, ToolHandler>;
+    resourceHandlers: Record<string, ResourceHandler>;
+    trackTelemetry: typeof trackTelemetry;
+};
+
+/**
+ * MCP Response Formatter
+ * Creates well-structured, human-friendly tool responses
+ *
+ * @package @bootspring/mcp
+ * @module response-formatter
+ */
+
+interface SuccessOptions {
+    summary?: string;
+    data?: unknown;
+    hints?: string[];
+    meta?: Record<string, unknown>;
+}
+interface ListOptions<T> {
+    title: string;
+    items: T[];
+    formatter?: (item: T, index: number) => string;
+    emptyMessage?: string;
+    hints?: string[];
+}
+interface AgentData {
+    name: string;
+    category?: string;
+    description: string;
+    expertise: string[];
+    systemPrompt?: string;
+}
+interface SkillData {
+    name: string;
+    description: string;
+    tags?: string[];
+}
+interface TodoItem {
+    text: string;
+    status?: string;
+}
+interface QualityGateResults {
+    name?: string;
+    gate?: string;
+    status: 'pass' | 'fail';
+    passed: number;
+    failed: number;
+    skipped?: number;
+    results: Array<{
+        name: string;
+        status: 'pass' | 'fail' | 'skip';
+        message?: string;
+    }>;
+}
+interface ContextValidationResult {
+    valid: boolean;
+    errors?: string[];
+    warnings?: string[];
+    suggestions?: string[];
+}
+interface ProjectContextDisplay {
+    project?: {
+        name?: string;
+        version?: string;
+    };
+    stack?: {
+        framework?: string;
+        language?: string;
+        database?: string;
+    };
+    plugins?: Record<string, unknown>;
+}
+interface OrchestratorStatus {
+    currentPhase?: string;
+    availableAgents?: number;
+    activeWorkflow?: string;
+    activeWorkflowSignalProgress?: {
+        completedSignals: unknown[];
+        totalSignals: number;
+    };
+    recentSuggestions?: Array<{
+        text?: string;
+    } | string>;
+}
+interface PRDData {
+    name: string;
+    stories: Array<{
+        title: string;
+        status: string;
+    }>;
+}
+interface ProgressInfo {
+    completed: number;
+    total: number;
+    percentage: number;
+}
+interface AssistResponseData {
+    confidenceTier?: 'high' | 'medium' | 'low' | 'very_low';
+    understood?: {
+        intent?: string;
+        confidence?: number;
+        description?: string;
+    };
+    primarySuggestion?: {
+        message: string;
+    };
+    clarificationNeeded?: boolean;
+    clarificationQuestion?: string;
+    clarificationOptions?: string[];
+    suggestions?: Array<{
+        message: string;
+    }>;
+    memoryInsight?: {
+        message: string;
+        recommendation: string;
+    };
+    recommendedTool?: {
+        name: string;
+        args: Record<string, unknown>;
+        reason: string;
+    };
+}
+interface MCPToolResultWithMeta extends MCPToolResult {
+    _meta?: Record<string, unknown>;
+}
+/**
+ * Format a success response
+ */
+declare function success(options: SuccessOptions): MCPToolResultWithMeta;
+/**
+ * Format an error response
+ */
+declare function error(message: string, suggestions?: string[]): MCPToolResult;
+/**
+ * Format a warning response
+ */
+declare function warning(message: string, suggestions?: string[]): MCPToolResult;
+/**
+ * Format a list response
+ */
+declare function list<T>(options: ListOptions<T>): MCPToolResult;
+/**
+ * Format agent details
+ */
+declare function agentDetails(id: string, agent: AgentData): MCPToolResult;
+/**
+ * Format skill details
+ */
+declare function skillDetails(id: string, skill: SkillData, content?: string | null): MCPToolResult;
+/**
+ * Format todo list
+ */
+declare function todoList(pending: TodoItem[], completed: TodoItem[]): MCPToolResult;
+/**
+ * Format quality gate results
+ */
+declare function qualityResults(results: QualityGateResults): MCPToolResult;
+/**
+ * Format context validation results
+ */
+declare function contextValidation(validation: ContextValidationResult): MCPToolResult;
+/**
+ * Format project context summary
+ */
+declare function contextSummary(ctx: ProjectContextDisplay): MCPToolResult;
+/**
+ * Format orchestrator status
+ */
+declare function orchestratorStatus(status: OrchestratorStatus): MCPToolResult;
+/**
+ * Format PRD/loop status
+ */
+declare function loopStatus(prd: PRDData, progress: ProgressInfo): MCPToolResult;
+/**
+ * Generate a progress bar
+ */
+declare function generateProgressBar(percentage: number): string;
+/**
+ * Format assist response
+ */
+declare function assistResponse(response: AssistResponseData): MCPToolResult;
+
+/**
+ * MCP Capabilities
+ * Capability manifest for assistant clients
+ *
+ * @package @bootspring/mcp
+ * @module capabilities
+ */
+
+interface BuildCapabilitiesOptions {
+    tier?: string;
+    entitled?: boolean;
+    mode?: string;
+    [key: string]: unknown;
+}
+interface WorkflowAccessContext {
+    mode: string;
+    tier: string;
+    entitled: boolean;
+    policyProfile: string;
+}
+interface PolicyProfile {
+    id: string;
+    allowExternalSkills: boolean;
+    blockedWorkflows: string[];
+}
+interface FilteredWorkflows {
+    allowed: WorkflowDefinition[];
+    denied: WorkflowDefinition[];
+}
+interface CapabilitiesDeps {
+    resolveWorkflowAccessContext: (options: BuildCapabilitiesOptions) => WorkflowAccessContext;
+    filterAccessibleWorkflows: (workflows: WorkflowDefinition[], options: BuildCapabilitiesOptions) => FilteredWorkflows;
+    getPolicyProfile: (profileId: string, options: BuildCapabilitiesOptions) => PolicyProfile;
+    listWorkflows: () => WorkflowDefinition[];
+}
+/**
+ * Build capabilities manifest
+ */
+declare function buildCapabilities(deps: CapabilitiesDeps, options?: BuildCapabilitiesOptions): CapabilitiesManifest;
+/**
+ * Build a default capabilities manifest for unauthenticated/local mode
+ */
+declare function buildDefaultCapabilities(): CapabilitiesManifest;
+
+export { type AgentData, type AssistResponseData, type BuildCapabilitiesOptions, type CapabilitiesDeps, type ContextValidationResult, type FilteredWorkflows, type ListOptions, type MCPServerOptions, type MCPToolResultWithMeta, type OrchestratorStatus, type PRDData, type PolicyProfile, type ProgressInfo, type ProjectContextDisplay, type QualityGateResults, type RegistryExports, type SkillData, type SuccessOptions, type TodoItem, type ValidationResult, type WorkflowAccessContext, agentDetails, assistResponse, buildCapabilities, buildDefaultCapabilities, clearCache, contextSummary, contextValidation, createServer, error, generateProgressBar, getCompatibilityRegistryCandidatePaths, getLegacyRegistryCandidatePaths, getRegistryExports, getResourceHandlers, getResources, getToolHandlers, getTools, invokeTool, isRegistryPopulated, list, loadToolsFromDirectory, loopStatus, main, orchestratorStatus, qualityResults, registerResource, registerTool, resolveCompatibilityRegistry, resolveRuntimeRegistry, skillDetails, startStdioServer, success, todoList, trackTelemetry, validateDependencies, warning };

package/dist/mcp/index.js

@@ -0,0 +1,2 @@
+'use strict';
+module.exports = require('../mcp-server.js');