miadi 1.0.14

package/src/index.ts

@@ -0,0 +1,510 @@
+#!/usr/bin/env node
+
+import dotenv from 'dotenv';
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { getEnvVar, logToolUsage, createMCPResponse, parseToolSelection, loadEnvironmentVariables } from './utils';
+import { ToolRegistry, ToolDefinition } from './tool-registry';
+import { memoryTools } from './tools/memory-tools';
+import { sessionTools } from './tools/session-tools';
+import { capabilityTools } from './tools/capability-tools';
+import { aiTools } from './tools/ai-tools';
+import { workflowTools } from './tools/workflow-tools';
+import { forgeTools } from './tools/forge-tools';
+import { z } from "zod";
+
+// Enhanced environment loading with fallback to $HOME/.env
+loadEnvironmentVariables();
+
+// Load environment variables from current directory .env (if it exists)
+dotenv.config();
+
+/**
+ * Miadi MCP Server
+ * 
+ * This server exposes the Miadi Three-Pathway Agent System API as MCP tools
+ * that Claude can use for agent session management, memory operations, and AI integration.
+ */
+
+// Validate required environment variables
+try {
+  getEnvVar('EH_TOKEN');
+  getEnvVar('EH_API_URL');
+  console.error('✅ Environment variables validated');
+} catch (error: any) {
+  console.error('❌ Environment validation failed:', error.message);
+  process.exit(1);
+}
+
+// Initialize tool registry with environment configuration
+const toolRegistry = new ToolRegistry(parseToolSelection());
+
+// Create MCP server instance
+const server = new McpServer(
+  {
+    name: "miadi-mcp-server",
+    version: "1.0.0",
+  },
+  {
+    capabilities: {
+      // Define capabilities if needed, e.g., "prompts": {}
+    },
+  }
+);
+
+/**
+ * Define all available tools with the registry
+ */
+function defineAllTools(): void {
+  // Memory Operations
+  toolRegistry.register({
+    name: 'miadi-get-memory',
+    category: 'memory',
+    description: 'Retrieve memory data from Redis',
+    schema: {
+      key: z.string().optional().describe('The key to retrieve from memory'),
+      list: z.boolean().optional().describe('Set to true to list all keys'),
+      pattern: z.string().optional().describe('Pattern to match when listing keys'),
+      type: z.enum(['auto', 'string', 'hash', 'list', 'set', 'zset']).optional().describe('Redis data type to retrieve')
+    },
+    handler: async (args: any) => {
+      logToolUsage('miadi-get-memory', args);
+      const { key, list, pattern, type } = args;
+      const result = await memoryTools.getMemory(key, list, pattern, type);
+      return createMCPResponse(result, 'miadi-get-memory');
+    }
+  });
+
+  toolRegistry.register({
+    name: 'miadi-store-memory',
+    category: 'memory',
+    description: 'Store data in memory with TTL',
+    schema: {
+      key: z.string().describe('The key to store the memory under'),
+      value: z.string().describe('The value to store'),
+      ttl: z.number().optional().describe('Time to live for the memory in seconds'),
+      type: z.enum(['string', 'hash', 'list']).optional().describe('Type of memory to store'),
+    },
+    handler: async (args: any) => {
+      logToolUsage('miadi-store-memory', args);
+      const { key, value, ttl, type } = args;
+      const result = await memoryTools.storeMemory(key, value, ttl, type);
+      return createMCPResponse(result, 'miadi-store-memory');
+    }
+  });
+
+  toolRegistry.register({
+    name: 'miadi-update-memory-ttl',
+    category: 'memory',
+    description: 'Update memory TTL',
+    schema: {
+      key: z.string().describe('The key to update TTL for'),
+      ttl: z.number().describe('Time to live in seconds')
+    },
+    handler: async (args: any) => {
+      logToolUsage('miadi-update-memory-ttl', args);
+      const { key, ttl } = args;
+      const result = await memoryTools.updateMemoryTTL(key, ttl);
+      return createMCPResponse(result, 'miadi-update-memory-ttl');
+    }
+  });
+
+  toolRegistry.register({
+    name: 'miadi-get-memory-meta',
+    category: 'memory',
+    description: 'Get memory meta',
+    schema: {
+      key: z.string().describe('The key to get metadata for')
+    },
+    handler: async (args: any) => {
+      logToolUsage('miadi-get-memory-meta', args);
+      const { key } = args;
+      const result = await memoryTools.getMemoryMeta(key);
+      return createMCPResponse(result, 'miadi-get-memory-meta');
+    }
+  });
+
+  toolRegistry.register({
+    name: 'miadi-scan-keys',
+    category: 'memory',
+    description: 'Scan Redis keys',
+    schema: {
+      pattern: z.string().optional().describe('Redis glob pattern for key matching (default: "*")'),
+      regex: z.string().optional().describe('Regular expression for key matching'),
+      limit: z.number().optional().describe('Maximum number of keys to return')
+    },
+    handler: async (args: any) => {
+      logToolUsage('miadi-scan-keys', args);
+      const { pattern, regex, limit } = args;
+      const result = await memoryTools.scanKeys(pattern, regex, limit);
+      return createMCPResponse(result, 'miadi-scan-keys');
+    }
+  });
+
+  toolRegistry.register({
+    name: 'miadi-gather-memory-values',
+    category: 'memory',
+    description: 'Gather memory values',
+    schema: {
+      pattern: z.string().optional().describe('Pattern to match when gathering keys'),
+      regex: z.string().optional().describe('Regular expression for key matching'),
+      limit: z.number().optional().describe('Maximum number of values to return'),
+      scanLimit: z.number().optional().describe('Maximum number of keys to scan')
+    },
+    handler: async (args: any) => {
+      logToolUsage('miadi-gather-memory-values', args);
+      const { pattern, regex, limit, scanLimit } = args;
+      const result = await memoryTools.gatherMemoryValues(pattern, regex, limit, scanLimit);
+      return createMCPResponse(result, 'miadi-gather-memory-values');
+    }
+  });
+
+  toolRegistry.register({
+    name: 'miadi-collect-memory',
+    category: 'memory',
+    description: 'Collect memory',
+    schema: {
+      keys: z.array(z.string()).describe('Array of keys to collect memory from')
+    },
+    handler: async (args: any) => {
+      logToolUsage('miadi-collect-memory', args);
+      const { keys } = args;
+      const result = await memoryTools.collectMemory(keys);
+      return createMCPResponse(result, 'miadi-collect-memory');
+    }
+  });
+
+  toolRegistry.register({
+    name: 'miadi-view-key-content',
+    category: 'memory',
+    description: 'View key content',
+    schema: {
+      key: z.string().describe('The key to view content for')
+    },
+    handler: async (args: any) => {
+      logToolUsage('miadi-view-key-content', args);
+      const { key } = args;
+      const result = await memoryTools.viewKeyContent(key);
+      return createMCPResponse(result, 'miadi-view-key-content');
+    }
+  });
+
+  toolRegistry.register({
+    name: 'miadi-search-cluster',
+    category: 'memory',
+    description: 'Search cluster',
+    schema: {
+      term: z.string().describe('Search term to find in cluster')
+    },
+    handler: async (args: any) => {
+      logToolUsage('miadi-search-cluster', args);
+      const { term } = args;
+      const result = await memoryTools.searchCluster(term);
+      return createMCPResponse(result, 'miadi-search-cluster');
+    }
+  });
+
+  // Session Management
+  toolRegistry.register({
+    name: 'miadi-start-session',
+    category: 'session',
+    description: 'Start new agent session',
+    schema: {
+      persona: z.string().describe('Persona ID to activate (e.g., "mia-recursive-architect")'),
+      mode: z.string().describe('Mode ID to activate (e.g., "desktop", "walking")'),
+      userId: z.string().optional().describe('User identifier'),
+      contextOverrides: z.array(z.object({
+        name: z.string(),
+        type: z.enum(['location', 'device', 'activity', 'time', 'custom']),
+        value: z.union([z.string(), z.number(), z.boolean(), z.record(z.any())]),
+        description: z.string().optional()
+      })).optional().describe('Context variable overrides')
+    },
+    handler: async (args: any) => {
+      logToolUsage('miadi-start-session', args);
+      const { persona, mode, userId, contextOverrides } = args;
+      const result = await sessionTools.startSession(persona, mode, userId, contextOverrides);
+      return createMCPResponse(result, 'miadi-start-session');
+    }
+  });
+
+  toolRegistry.register({
+    name: 'miadi-get-current-session',
+    category: 'session',
+    description: 'Get current session details',
+    schema: {
+      sessionId: z.string().optional().describe('Session ID to retrieve details for')
+    },
+    handler: async (args: any) => {
+      logToolUsage('miadi-get-current-session', args);
+      const { sessionId } = args;
+      const result = await sessionTools.getCurrentSession(sessionId);
+      return createMCPResponse(result, 'miadi-get-current-session');
+    }
+  });
+
+  toolRegistry.register({
+    name: 'miadi-switch-mode',
+    category: 'session',
+    description: 'Switch mode in existing session',
+    schema: {
+      sessionId: z.string().describe('Session ID to switch mode for'),
+      newMode: z.string().describe('New mode ID to activate'),
+      contextOverrides: z.array(z.object({
+        name: z.string(),
+        type: z.enum(['location', 'device', 'activity', 'time', 'custom']),
+        value: z.union([z.string(), z.number(), z.boolean(), z.record(z.any())]),
+        description: z.string().optional()
+      })).optional().describe('Context variable overrides')
+    },
+    handler: async (args: any) => {
+      logToolUsage('miadi-switch-mode', args);
+      const { sessionId, newMode, contextOverrides } = args;
+      const result = await sessionTools.switchMode(sessionId, newMode, contextOverrides);
+      return createMCPResponse(result, 'miadi-switch-mode');
+    }
+  });
+
+  toolRegistry.register({
+    name: 'miadi-switch-persona',
+    category: 'session',
+    description: 'Switch persona in session',
+    schema: {
+      sessionId: z.string().describe('Session ID to switch persona for'),
+      newPersona: z.string().describe('New persona ID to activate'),
+      preserveMode: z.boolean().optional().describe('Whether to preserve current mode')
+    },
+    handler: async (args: any) => {
+      logToolUsage('miadi-switch-persona', args);
+      const { sessionId, newPersona, preserveMode } = args;
+      const result = await sessionTools.switchPersona(sessionId, newPersona, preserveMode);
+      return createMCPResponse(result, 'miadi-switch-persona');
+    }
+  });
+
+  toolRegistry.register({
+    name: 'miadi-end-session',
+    category: 'session',
+    description: 'End active session',
+    schema: {
+      sessionId: z.string().describe('Session ID to end')
+    },
+    handler: async (args: any) => {
+      logToolUsage('miadi-end-session', args);
+      const { sessionId } = args;
+      const result = await sessionTools.endSession(sessionId);
+      return createMCPResponse(result, 'miadi-end-session');
+    }
+  });
+
+  toolRegistry.register({
+    name: 'miadi-list-sessions',
+    category: 'session',
+    description: 'List active sessions',
+    schema: {
+      userId: z.string().optional().describe('User ID to filter sessions by'),
+      limit: z.number().optional().describe('Maximum number of sessions to return'),
+      offset: z.number().optional().describe('Offset for pagination')
+    },
+    handler: async (args: any) => {
+      logToolUsage('miadi-list-sessions', args);
+      const { userId, limit, offset } = args;
+      const result = await sessionTools.listSessions(userId, limit, offset);
+      return createMCPResponse(result, 'miadi-list-sessions');
+    }
+  });
+
+  // Capability Resolution
+  toolRegistry.register({
+    name: 'miadi-resolve-capabilities',
+    category: 'capability',
+    description: 'Resolve capabilities for persona/mode',
+    schema: {
+      persona: z.string().describe('Persona ID to resolve capabilities for'),
+      mode: z.string().describe('Mode ID to resolve capabilities for'),
+      context: z.record(z.any()).optional().describe('Context variables for capability resolution')
+    },
+    handler: async (args: any) => {
+      logToolUsage('miadi-resolve-capabilities', args);
+      const { persona, mode, context } = args;
+      const result = await capabilityTools.resolveCapabilities(persona, mode, context);
+      return createMCPResponse(result, 'miadi-resolve-capabilities');
+    }
+  });
+
+  toolRegistry.register({
+    name: 'miadi-get-agent-info',
+    category: 'capability',
+    description: 'Get comprehensive agent system info',
+    schema: {},
+    handler: async (args: any) => {
+      logToolUsage('miadi-get-agent-info', args);
+      const result = await capabilityTools.getAgentInfo();
+      return createMCPResponse(result, 'miadi-get-agent-info');
+    }
+  });
+
+  toolRegistry.register({
+    name: 'miadi-detect-cues',
+    category: 'capability',
+    description: 'Detect mode/persona switch cues from text',
+    schema: {
+      text: z.string().describe('Text to analyze for cues'),
+      currentSession: z.record(z.any()).optional().describe('Current session context'),
+      availableModes: z.array(z.string()).optional().describe('Available modes to detect cues for'),
+      availablePersonas: z.array(z.string()).optional().describe('Available personas to detect cues for')
+    },
+    handler: async (args: any) => {
+      logToolUsage('miadi-detect-cues', args);
+      const { text, currentSession, availableModes, availablePersonas } = args;
+      const result = await capabilityTools.detectCues(text, currentSession, availableModes, availablePersonas);
+      return createMCPResponse(result, 'miadi-detect-cues');
+    }
+  });
+
+  // AI Integration
+  toolRegistry.register({
+    name: 'miadi-openai-request',
+    category: 'ai',
+    description: 'Make OpenAI API requests',
+    schema: {
+      prompt: z.string().describe('Prompt to send to OpenAI'),
+      modelId: z.string().optional().describe('OpenAI model ID to use'),
+      maxTokens: z.number().optional().describe('Maximum tokens to generate'),
+      temperature: z.number().optional().describe('Temperature for response generation'),
+      stream: z.boolean().optional().describe('Whether to stream the response')
+    },
+    handler: async (args: any) => {
+      logToolUsage('miadi-openai-request', args);
+      const { prompt, modelId, maxTokens, temperature, stream } = args;
+      const result = await aiTools.openaiRequest(prompt, modelId, maxTokens, temperature, stream);
+      return createMCPResponse(result, 'miadi-openai-request');
+    }
+  });
+
+  toolRegistry.register({
+    name: 'miadi-ai-request',
+    category: 'ai',
+    description: 'Make generic AI requests',
+    schema: {
+      prompt: z.string().describe('Prompt to send to AI model'),
+      modelId: z.string().optional().describe('AI model ID to use'),
+      maxTokens: z.number().optional().describe('Maximum tokens to generate'),
+      temperature: z.number().optional().describe('Temperature for response generation')
+    },
+    handler: async (args: any) => {
+      logToolUsage('miadi-ai-request', args);
+      const { prompt, modelId, maxTokens, temperature } = args;
+      const result = await aiTools.aiRequest(prompt, modelId, maxTokens, temperature);
+      return createMCPResponse(result, 'miadi-ai-request');
+    }
+  });
+
+  // Workflow Management
+  toolRegistry.register({
+    name: 'miadi-register-agent',
+    category: 'workflow',
+    description: 'Register agent for GitHub events',
+    schema: {
+      agentId: z.string().describe('Agent ID to register'),
+      eventTypes: z.array(z.string()).describe('Event types to register for'),
+      callbackUrl: z.string().describe('Callback URL for events')
+    },
+    handler: async (args: any) => {
+      logToolUsage('miadi-register-agent', args);
+      const { agentId, eventTypes, callbackUrl } = args;
+      const result = await workflowTools.registerAgent(agentId, eventTypes, callbackUrl);
+      return createMCPResponse(result, 'miadi-register-agent');
+    }
+  });
+
+  toolRegistry.register({
+    name: 'miadi-get-agent-events',
+    category: 'workflow',
+    description: 'Check for agent events',
+    schema: {
+      agentId: z.string().describe('Agent ID to check events for')
+    },
+    handler: async (args: any) => {
+      logToolUsage('miadi-get-agent-events', args);
+      const { agentId } = args;
+      const result = await workflowTools.getAgentEvents(agentId);
+      return createMCPResponse(result, 'miadi-get-agent-events');
+    }
+  });
+
+  toolRegistry.register({
+    name: 'miadi-get-workflow-howto',
+    category: 'workflow',
+    description: 'Get workflow setup guides',
+    schema: {
+      topic: z.string().describe('Topic to get workflow guide for')
+    },
+    handler: async (args: any) => {
+      logToolUsage('miadi-get-workflow-howto', args);
+      const { topic } = args;
+      const result = await workflowTools.getWorkflowHowto(topic);
+      return createMCPResponse(result, 'miadi-get-workflow-howto');
+    }
+  });
+
+  // Forge Operations
+  toolRegistry.register({
+    name: 'miadi-get-forge-state',
+    category: 'forge',
+    description: 'Get current forge state',
+    schema: {},
+    handler: async (args: any) => {
+      logToolUsage('miadi-get-forge-state', args);
+      const result = await forgeTools.getForgeState();
+      return createMCPResponse(result, 'miadi-get-forge-state');
+    }
+  });
+
+  toolRegistry.register({
+    name: 'miadi-update-forge-state',
+    category: 'forge',
+    description: 'Update forge state',
+    schema: {
+      state: z.record(z.any()).describe('New forge state data')
+    },
+    handler: async (args: any) => {
+      logToolUsage('miadi-update-forge-state', args);
+      const { state } = args;
+      const result = await forgeTools.updateForgeState(state);
+      return createMCPResponse(result, 'miadi-update-forge-state');
+    }
+  });
+
+  toolRegistry.register({
+    name: 'miadi-get-glyph-map',
+    category: 'forge',
+    description: 'Get glyph map information',
+    schema: {},
+    handler: async (args: any) => {
+      logToolUsage('miadi-get-glyph-map', args);
+      const result = await forgeTools.getGlyphMap();
+      return createMCPResponse(result, 'miadi-get-glyph-map');
+    }
+  });
+}
+
+async function main() {
+  // Define all tools
+  defineAllTools();
+  
+  // Log configuration summary
+  console.error(toolRegistry.getConfigSummary());
+  
+  // Register enabled tools with MCP server
+  toolRegistry.registerAllEnabledTools(server);
+  
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("✅ Miadi MCP Server is ready and listening!");
+}
+
+main().catch((error) => {
+  console.error("❌ Failed to start MCP server:", error);
+  process.exit(1);
+});