miadi 1.0.14 → 2.0.0

package/src/tool-registry.ts

@@ -1,223 +0,0 @@
-/**
- * Tool Registry System for Miadi MCP Server
- * 
- * Provides environment variable-based tool selection to allow selective exposure
- * of MCP tools based on deployment requirements, security constraints, and use cases.
- */
-
-import { z } from "zod";
-
-/**
- * Definition of a tool that can be registered with the MCP server
- */
-export interface ToolDefinition {
-  name: string;
-  category: string;
-  description: string;
-  schema: Record<string, z.ZodType<any>>;
-  handler: (args: any) => Promise<any>;
-  dependencies?: string[];
-}
-
-/**
- * Configuration for tool registry behavior
- */
-export interface ToolRegistryConfig {
-  enabledCategories?: string[];
-  enabledTools?: string[];
-  disabledCategories?: string[];
-  disabledTools?: string[];
-  defaultEnabled?: boolean;
-}
-
-/**
- * Category mappings for tool organization
- */
-export const TOOL_CATEGORIES = {
-  memory: [
-    'miadi-get-memory', 'miadi-store-memory', 'miadi-update-memory-ttl',
-    'miadi-get-memory-meta', 'miadi-scan-keys', 'miadi-gather-memory-values',
-    'miadi-collect-memory', 'miadi-view-key-content', 'miadi-search-cluster'
-  ],
-  session: [
-    'miadi-start-session', 'miadi-get-current-session', 'miadi-switch-mode',
-    'miadi-switch-persona', 'miadi-end-session', 'miadi-list-sessions'
-  ],
-  capability: [
-    'miadi-resolve-capabilities', 'miadi-get-agent-info', 'miadi-detect-cues'
-  ],
-  ai: ['miadi-openai-request', 'miadi-ai-request'],
-  workflow: [
-    'miadi-register-agent', 'miadi-get-agent-events', 'miadi-get-workflow-howto'
-  ],
-  forge: [
-    'miadi-get-forge-state', 'miadi-update-forge-state', 'miadi-get-glyph-map'
-  ]
-};
-
-/**
- * Registry for managing MCP tool registration with environment-based selection
- */
-export class ToolRegistry {
-  private tools: Map<string, ToolDefinition> = new Map();
-  private config: ToolRegistryConfig;
-
-  constructor(config: ToolRegistryConfig) {
-    this.config = config;
-    this.validateConfig();
-  }
-
-  /**
-   * Register a tool with the registry
-   */
-  register(tool: ToolDefinition): void {
-    this.tools.set(tool.name, tool);
-  }
-
-  /**
-   * Check if a specific tool should be enabled based on configuration
-   */
-  isToolEnabled(toolName: string): boolean {
-    const tool = this.tools.get(toolName);
-    if (!tool) return false;
-
-    // Check category-level enablement
-    const categoryEnabled = this.isCategoryEnabled(tool.category);
-    const toolSpecificallyDisabled = this.config.disabledTools?.includes(toolName);
-    const toolSpecificallyEnabled = this.config.enabledTools?.includes(toolName);
-
-    // Priority: specific tool settings > category settings > default
-    if (toolSpecificallyEnabled) return true;
-    if (toolSpecificallyDisabled) return false;
-    return categoryEnabled;
-  }
-
-  /**
-   * Check if a category should be enabled based on configuration
-   */
-  private isCategoryEnabled(category: string): boolean {
-    // If specific tools are enabled but no categories are specified,
-    // default to false for category-based enablement
-    if (this.config.enabledTools && !this.config.enabledCategories) {
-      return false;
-    }
-    
-    if (this.config.enabledCategories) {
-      return this.config.enabledCategories.includes(category);
-    }
-    if (this.config.disabledCategories) {
-      return !this.config.disabledCategories.includes(category);
-    }
-    return this.config.defaultEnabled ?? true;
-  }
-
-  /**
-   * Get all enabled tools
-   */
-  getEnabledTools(): ToolDefinition[] {
-    return Array.from(this.tools.values()).filter(tool => 
-      this.isToolEnabled(tool.name)
-    );
-  }
-
-  /**
-   * Get all registered tools (regardless of enabled status)
-   */
-  getAllTools(): ToolDefinition[] {
-    return Array.from(this.tools.values());
-  }
-
-  /**
-   * Validate the registry configuration
-   */
-  validateConfig(): void {
-    const validCategories = Object.keys(TOOL_CATEGORIES);
-    
-    const checkCategories = (categories?: string[], context: string = '') => {
-      categories?.forEach(cat => {
-        if (!validCategories.includes(cat)) {
-          console.error(`⚠️  Unknown category in ${context}: ${cat}`);
-          console.error(`   Valid categories: ${validCategories.join(', ')}`);
-        }
-      });
-    };
-
-    checkCategories(this.config.enabledCategories, 'enabledCategories');
-    checkCategories(this.config.disabledCategories, 'disabledCategories');
-
-    // Check for conflicting configuration
-    if (this.config.enabledCategories && this.config.disabledCategories) {
-      const conflict = this.config.enabledCategories.find(cat => 
-        this.config.disabledCategories?.includes(cat)
-      );
-      if (conflict) {
-        console.error(`⚠️  Category '${conflict}' is both enabled and disabled`);
-      }
-    }
-  }
-
-  /**
-   * Register all enabled tools with the MCP server
-   */
-  registerAllEnabledTools(server: any): void {
-    const enabledTools = this.getEnabledTools();
-    const totalTools = this.tools.size;
-    
-    console.error(`🔧 Tool Registry Configuration:`);
-    console.error(`   Total tools available: ${totalTools}`);
-    console.error(`   Tools to register: ${enabledTools.length}`);
-    
-    if (enabledTools.length < totalTools) {
-      const disabledCount = totalTools - enabledTools.length;
-      console.error(`   Tools disabled: ${disabledCount}`);
-    }
-
-    // Group enabled tools by category for logging
-    const enabledByCategory: Record<string, string[]> = {};
-    enabledTools.forEach(tool => {
-      if (!enabledByCategory[tool.category]) {
-        enabledByCategory[tool.category] = [];
-      }
-      enabledByCategory[tool.category].push(tool.name);
-    });
-
-    console.error(`📋 Enabled tool categories:`);
-    Object.entries(enabledByCategory).forEach(([category, tools]) => {
-      console.error(`   ${category}: ${tools.length} tools`);
-    });
-    
-    enabledTools.forEach(tool => {
-      server.tool(tool.name, tool.description, tool.schema, tool.handler);
-    });
-
-    console.error(`✅ ${enabledTools.length} tools registered successfully`);
-  }
-
-  /**
-   * Get configuration summary for debugging
-   */
-  getConfigSummary(): string {
-    const lines = ['Tool Registry Configuration:'];
-    
-    if (this.config.enabledCategories) {
-      lines.push(`  Enabled Categories: ${this.config.enabledCategories.join(', ')}`);
-    }
-    if (this.config.disabledCategories) {
-      lines.push(`  Disabled Categories: ${this.config.disabledCategories.join(', ')}`);
-    }
-    if (this.config.enabledTools) {
-      lines.push(`  Enabled Tools: ${this.config.enabledTools.join(', ')}`);
-    }
-    if (this.config.disabledTools) {
-      lines.push(`  Disabled Tools: ${this.config.disabledTools.join(', ')}`);
-    }
-    
-    lines.push(`  Default Enabled: ${this.config.defaultEnabled ?? true}`);
-    
-    const enabledCount = this.getEnabledTools().length;
-    const totalCount = this.tools.size;
-    lines.push(`  Result: ${enabledCount}/${totalCount} tools enabled`);
-    
-    return lines.join('\n');
-  }
-}

package/src/tools/ai-tools.ts

@@ -1,69 +0,0 @@
-import { miadiApi } from '../api-client';
-import {
-  OpenAIRequest,
-  OpenAIResponse,
-  AIRequest,
-  AIResponse
-} from '../types';
-
-export const aiTools = {
-  /**
-   * Make a request to OpenAI API through Miadi system
-   */
-  openaiRequest: async (
-    prompt: string,
-    modelId?: string,
-    maxTokens?: number,
-    temperature?: number,
-    stream?: boolean
-  ): Promise<OpenAIResponse> => {
-    try {
-      if (!prompt) {
-        throw new Error('Prompt is required');
-      }
-
-      const requestBody: OpenAIRequest = {
-        prompt
-      };
-
-      if (modelId) requestBody.modelId = modelId;
-      if (maxTokens !== undefined) requestBody.maxTokens = maxTokens;
-      if (temperature !== undefined) requestBody.temperature = temperature;
-      if (stream !== undefined) requestBody.stream = stream;
-
-      return await miadiApi.openaiRequest(requestBody);
-    } catch (error: any) {
-      throw new Error(`Failed to make OpenAI request: ${error.message}`);
-    }
-  },
-
-  /**
-   * Make a generic AI request through Miadi system
-   */
-  aiRequest: async (
-    prompt: string,
-    modelId?: string,
-    maxTokens?: number,
-    temperature?: number
-  ): Promise<AIResponse> => {
-    try {
-      if (!prompt) {
-        throw new Error('Prompt is required');
-      }
-
-      const requestBody: AIRequest = {
-        prompt
-      };
-
-      if (modelId) requestBody.modelId = modelId;
-      if (maxTokens !== undefined) requestBody.maxTokens = maxTokens;
-      if (temperature !== undefined) requestBody.temperature = temperature;
-
-      return await miadiApi.aiRequest(requestBody);
-    } catch (error: any) {
-      throw new Error(`Failed to make AI request: ${error.message}`);
-    }
-  }
-};
-
-export default aiTools;

package/src/tools/capability-tools.ts

@@ -1,79 +0,0 @@
-import { miadiApi } from '../api-client';
-import {
-  CapabilityResolveRequest,
-  CapabilityResolveResponse,
-  AgentInfoResponse,
-  CueDetectRequest,
-  CueDetectResponse,
-  ContextVariable,
-  AgentSession
-} from '../types';
-
-export const capabilityTools = {
-  /**
-   * Resolve capabilities for persona/mode combination
-   */
-  resolveCapabilities: async (
-    persona: string,
-    mode: string,
-    context?: ContextVariable[]
-  ): Promise<CapabilityResolveResponse> => {
-    try {
-      if (!persona || !mode) {
-        throw new Error('Persona and mode are required');
-      }
-
-      const requestBody: CapabilityResolveRequest = {
-        persona,
-        mode
-      };
-
-      if (context) requestBody.context = context;
-
-      return await miadiApi.resolveCapabilities(requestBody);
-    } catch (error: any) {
-      throw new Error(`Failed to resolve capabilities: ${error.message}`);
-    }
-  },
-
-  /**
-   * Get comprehensive agent system information
-   */
-  getAgentInfo: async (): Promise<AgentInfoResponse> => {
-    try {
-      return await miadiApi.getAgentInfo();
-    } catch (error: any) {
-      throw new Error(`Failed to get agent info: ${error.message}`);
-    }
-  },
-
-  /**
-   * Detect mode/persona switch cues from natural language text
-   */
-  detectCues: async (
-    text: string,
-    currentSession?: AgentSession,
-    availableModes?: string[],
-    availablePersonas?: string[]
-  ): Promise<CueDetectResponse> => {
-    try {
-      if (!text) {
-        throw new Error('Text is required for cue detection');
-      }
-
-      const requestBody: CueDetectRequest = {
-        text
-      };
-
-      if (currentSession) requestBody.currentSession = currentSession;
-      if (availableModes) requestBody.availableModes = availableModes;
-      if (availablePersonas) requestBody.availablePersonas = availablePersonas;
-
-      return await miadiApi.detectCues(requestBody);
-    } catch (error: any) {
-      throw new Error(`Failed to detect cues: ${error.message}`);
-    }
-  }
-};
-
-export default capabilityTools;

package/src/tools/forge-tools.ts

@@ -1,51 +0,0 @@
-import { miadiApi } from '../api-client';
-import {
-  ForgeStateRequest,
-  ForgeStateResponse,
-  ForgeStateUpdateResponse
-} from '../types';
-
-export const forgeTools = {
-  /**
-   * Get the current forge state
-   */
-  getForgeState: async (): Promise<ForgeStateResponse> => {
-    try {
-      return await miadiApi.getForgeState();
-    } catch (error: any) {
-      throw new Error(`Failed to get forge state: ${error.message}`);
-    }
-  },
-
-  /**
-   * Update the forge state (open/close)
-   */
-  updateForgeState: async (state: boolean): Promise<ForgeStateUpdateResponse> => {
-    try {
-      if (typeof state !== 'boolean') {
-        throw new Error('State must be a boolean value (true for open, false for closed)');
-      }
-
-      const requestBody: ForgeStateRequest = {
-        state
-      };
-
-      return await miadiApi.updateForgeState(requestBody);
-    } catch (error: any) {
-      throw new Error(`Failed to update forge state: ${error.message}`);
-    }
-  },
-
-  /**
-   * Get glyph map information
-   */
-  getGlyphMap: async (): Promise<any> => {
-    try {
-      return await miadiApi.getGlyphMap();
-    } catch (error: any) {
-      throw new Error(`Failed to get glyph map: ${error.message}`);
-    }
-  }
-};
-
-export default forgeTools;

package/src/tools/memory-tools.ts

@@ -1,137 +0,0 @@
-import { miadiApi } from '../api-client';
-import { GetMemoryResponse, StoreMemoryRequest, StoreMemoryResponse, ScanResponse, GatherMemoryResponse } from '../types';
-
-export const memoryTools = {
-  /**
-   * Retrieve memory data from Redis storage
-   */
-  getMemory: async (
-    key?: string,
-    list?: boolean,
-    pattern?: string,
-    type?: 'auto' | 'string' | 'hash' | 'list' | 'set' | 'zset'
-  ): Promise<GetMemoryResponse> => {
-    try {
-      return await miadiApi.getMemory(key, list, pattern, type);
-    } catch (error: any) {
-      throw new Error(`Failed to retrieve memory: ${error.message}`);
-    }
-  },
-
-  /**
-   * Store data in memory with optional TTL and type
-   */
-  storeMemory: async (
-    key: string,
-    value: string,
-    ttl?: number,
-    type?: 'string' | 'hash' | 'list'
-  ): Promise<StoreMemoryResponse> => {
-    try {
-      const requestBody: StoreMemoryRequest = { key, value };
-      if (ttl !== undefined) requestBody.ttl = ttl;
-      if (type) requestBody.type = type;
-      
-      return await miadiApi.storeMemory(requestBody);
-    } catch (error: any) {
-      throw new Error(`Failed to store memory: ${error.message}`);
-    }
-  },
-
-  /**
-   * Update TTL for an existing memory key
-   */
-  updateMemoryTTL: async (key: string, ttl: number): Promise<any> => {
-    try {
-      return await miadiApi.updateMemoryTTL(key, ttl);
-    } catch (error: any) {
-      throw new Error(`Failed to update memory TTL: ${error.message}`);
-    }
-  },
-
-  /**
-   * Get metadata for a memory key
-   */
-  getMemoryMeta: async (key: string): Promise<any> => {
-    try {
-      return await miadiApi.getMemoryMeta(key);
-    } catch (error: any) {
-      throw new Error(`Failed to get memory metadata: ${error.message}`);
-    }
-  },
-
-  /**
-   * Scan Redis keys using pattern matching or regex
-   */
-  scanKeys: async (
-    pattern?: string,
-    regex?: string,
-    limit?: number
-  ): Promise<ScanResponse> => {
-    try {
-      return await miadiApi.scanKeys(pattern, regex, limit);
-    } catch (error: any) {
-      throw new Error(`Failed to scan keys: ${error.message}`);
-    }
-  },
-
-  /**
-   * Gather memory values using pattern matching
-   */
-  gatherMemoryValues: async (
-    pattern?: string,
-    regex?: string,
-    limit?: number,
-    scanLimit?: number
-  ): Promise<GatherMemoryResponse> => {
-    try {
-      return await miadiApi.gatherMemoryValues(pattern, regex, limit, scanLimit);
-    } catch (error: any) {
-      throw new Error(`Failed to gather memory values: ${error.message}`);
-    }
-  },
-
-  /**
-   * Collect specific memory values by keys
-   */
-  collectMemory: async (keys: string[]): Promise<any> => {
-    try {
-      if (!keys || keys.length === 0) {
-        throw new Error('Keys array is required and cannot be empty');
-      }
-      return await miadiApi.collectMemory(keys);
-    } catch (error: any) {
-      throw new Error(`Failed to collect memory: ${error.message}`);
-    }
-  },
-
-  /**
-   * View key content for cluster operations
-   */
-  viewKeyContent: async (key: string): Promise<any> => {
-    try {
-      if (!key) {
-        throw new Error('Key is required');
-      }
-      return await miadiApi.viewKeyContent(key);
-    } catch (error: any) {
-      throw new Error(`Failed to view key content: ${error.message}`);
-    }
-  },
-
-  /**
-   * Search cluster for keys
-   */
-  searchCluster: async (term: string): Promise<{ keys: string[] }> => {
-    try {
-      if (!term) {
-        throw new Error('Search term is required');
-      }
-      return await miadiApi.searchCluster(term);
-    } catch (error: any) {
-      throw new Error(`Failed to search cluster: ${error.message}`);
-    }
-  }
-};
-
-export default memoryTools;

package/src/tools/session-tools.ts

@@ -1,135 +0,0 @@
-import { miadiApi } from '../api-client';
-import {
-  SessionStartRequest,
-  SessionStartResponse,
-  SessionCurrentResponse,
-  SessionSwitchModeRequest,
-  SessionSwitchPersonaRequest,
-  SessionListResponse,
-  ContextVariable
-} from '../types';
-
-export const sessionTools = {
-  /**
-   * Start a new agent session with specified persona and mode
-   */
-  startSession: async (
-    persona: string,
-    mode: string,
-    userId?: string,
-    contextOverrides?: ContextVariable[]
-  ): Promise<SessionStartResponse> => {
-    try {
-      if (!persona || !mode) {
-        throw new Error('Persona and mode are required');
-      }
-
-      const requestBody: SessionStartRequest = {
-        persona,
-        mode
-      };
-
-      if (userId) requestBody.userId = userId;
-      if (contextOverrides) requestBody.contextOverrides = contextOverrides;
-
-      return await miadiApi.startSession(requestBody);
-    } catch (error: any) {
-      throw new Error(`Failed to start session: ${error.message}`);
-    }
-  },
-
-  /**
-   * Get current session details
-   */
-  getCurrentSession: async (sessionId?: string): Promise<SessionCurrentResponse> => {
-    try {
-      return await miadiApi.getCurrentSession(sessionId);
-    } catch (error: any) {
-      throw new Error(`Failed to get current session: ${error.message}`);
-    }
-  },
-
-  /**
-   * Switch mode in an existing session
-   */
-  switchMode: async (
-    sessionId: string,
-    newMode: string,
-    contextOverrides?: ContextVariable[]
-  ): Promise<SessionCurrentResponse> => {
-    try {
-      if (!sessionId || !newMode) {
-        throw new Error('Session ID and new mode are required');
-      }
-
-      const requestBody: SessionSwitchModeRequest = {
-        sessionId,
-        newMode
-      };
-
-      if (contextOverrides) requestBody.contextOverrides = contextOverrides;
-
-      return await miadiApi.switchMode(requestBody);
-    } catch (error: any) {
-      throw new Error(`Failed to switch mode: ${error.message}`);
-    }
-  },
-
-  /**
-   * Switch persona in an existing session
-   */
-  switchPersona: async (
-    sessionId: string,
-    newPersona: string,
-    preserveMode?: boolean
-  ): Promise<SessionCurrentResponse> => {
-    try {
-      if (!sessionId || !newPersona) {
-        throw new Error('Session ID and new persona are required');
-      }
-
-      const requestBody: SessionSwitchPersonaRequest = {
-        sessionId,
-        newPersona
-      };
-
-      if (preserveMode !== undefined) requestBody.preserveMode = preserveMode;
-
-      return await miadiApi.switchPersona(requestBody);
-    } catch (error: any) {
-      throw new Error(`Failed to switch persona: ${error.message}`);
-    }
-  },
-
-  /**
-   * End an active session
-   */
-  endSession: async (sessionId: string): Promise<{ success: boolean; message: string; timestamp: string }> => {
-    try {
-      if (!sessionId) {
-        throw new Error('Session ID is required');
-      }
-
-      return await miadiApi.endSession(sessionId);
-    } catch (error: any) {
-      throw new Error(`Failed to end session: ${error.message}`);
-    }
-  },
-
-  /**
-   * List active sessions with optional filtering
-   */
-  listSessions: async (
-    userId?: string,
-    limit?: number,
-    offset?: number
-  ): Promise<SessionListResponse> => {
-    try {
-      return await miadiApi.listSessions(userId, limit, offset);
-    } catch (error: any) {
-      throw new Error(`Failed to list sessions: ${error.message}`);
-    }
-  }
-};
-
-export default sessionTools;