Skip to main content
Glama

check_ai_execution_status

Check AI execution configuration and status to debug prompt-only mode issues in architectural decision record analysis.

Instructions

Check AI execution configuration and status for debugging prompt-only mode issues

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault

No arguments

Implementation Reference

  • The core handler function getAIExecutionStatus() that checks AI configuration, API key presence, execution mode, and returns detailed status. This implements the tool logic.
    export function getAIExecutionStatus(): {
      isEnabled: boolean;
      hasApiKey: boolean;
      executionMode: string;
      model: string;
      reason: string | undefined;
    } {
      try {
        const config = loadAIConfig();
        const hasApiKey = !!config.apiKey;
        const isEnabled = isAIExecutionEnabled(config);
    
        let reason: string | undefined = undefined;
        if (!hasApiKey) {
          reason = 'Missing OPENROUTER_API_KEY environment variable';
        } else if (config.executionMode !== 'full') {
          reason = `EXECUTION_MODE is '${config.executionMode}', should be 'full'`;
        }
    
        return {
          isEnabled,
          hasApiKey,
          executionMode: config.executionMode,
          model: config.defaultModel,
          reason,
        };
      } catch (error) {
        return {
          isEnabled: false,
          hasApiKey: false,
          executionMode: 'unknown',
          model: 'unknown',
          reason: `Configuration error: ${error instanceof Error ? error.message : String(error)}`,
        };
      }
    }
  • Tool metadata and input/output schema definition in the central TOOL_CATALOG. Defines empty input schema (no parameters) matching the simple status check nature.
    TOOL_CATALOG.set('check_ai_execution_status', {
      name: 'check_ai_execution_status',
      shortDescription: 'Check AI execution status',
      fullDescription: 'Checks the status of AI execution capabilities.',
      category: 'utility',
      complexity: 'simple',
      tokenCost: { min: 100, max: 300 },
      hasCEMCPDirective: true, // Phase 4.3: Simple tool - status check
      relatedTools: ['get_server_context'],
      keywords: ['ai', 'status', 'check', 'execution'],
      requiresAI: false,
      inputSchema: {
        type: 'object',
        properties: {},
      },
    });
  • Registration of the tool in the central catalog which provides metadata for dynamic tool discovery and MCP ListTools responses.
      inputSchema: {
        type: 'object',
        properties: {
          adrIds: { type: 'array', items: { type: 'string' } },
        },
      },
    });
    
    TOOL_CATALOG.set('review_existing_adrs', {
      name: 'review_existing_adrs',
      shortDescription: 'Review and analyze existing ADRs',
      fullDescription: 'Reviews existing ADRs for relevance, accuracy, and potential updates.',
      category: 'adr',
      complexity: 'moderate',
      tokenCost: { min: 2000, max: 4000 },
      hasCEMCPDirective: true, // Phase 4.3: Moderate tool - ADR review
      relatedTools: ['validate_all_adrs', 'suggest_adrs'],
      keywords: ['adr', 'review', 'analyze', 'update'],
      requiresAI: true,
      inputSchema: {
        type: 'object',
        properties: {
          focusArea: { type: 'string' },
          includeRecommendations: { type: 'boolean', default: true },
        },
      },
    });
    
    TOOL_CATALOG.set('generate_adr_bootstrap', {
      name: 'generate_adr_bootstrap',
      shortDescription: 'Bootstrap ADR infrastructure',
      fullDescription:
        'Sets up ADR infrastructure including templates, directory structure, and initial ADRs.',
      category: 'adr',
      complexity: 'simple',
      tokenCost: { min: 500, max: 1500 },
      hasCEMCPDirective: true, // Phase 4.3: Simple tool - setup/initialization
      relatedTools: ['suggest_adrs', 'generate_adr_from_decision'],
      keywords: ['adr', 'bootstrap', 'setup', 'initialize'],
      requiresAI: false,
      inputSchema: {
        type: 'object',
        properties: {
          outputDirectory: { type: 'string', default: 'docs/adrs' },
          includeTemplate: { type: 'boolean', default: true },
        },
      },
    });
    
    TOOL_CATALOG.set('interactive_adr_planning', {
      name: 'interactive_adr_planning',
      shortDescription: 'Interactive ADR planning session',
      fullDescription:
        'Guides through an interactive ADR planning session to identify and prioritize decisions.',
      category: 'adr',
      complexity: 'complex',
      tokenCost: { min: 3000, max: 6000 },
      hasCEMCPDirective: true, // Phase 4.2: CE-MCP directive added
      relatedTools: ['suggest_adrs', 'generate_adr_from_decision'],
      keywords: ['adr', 'planning', 'interactive', 'session'],
      requiresAI: true,
      inputSchema: {
        type: 'object',
        properties: {
          projectPath: { type: 'string' },
          sessionMode: { type: 'string', enum: ['guided', 'free-form'] },
        },
        required: ['projectPath'],
      },
    });
    
    // ============================================================================
    // CONTENT SECURITY TOOLS
    // ============================================================================
    
    TOOL_CATALOG.set('analyze_content_security', {
      name: 'analyze_content_security',
      shortDescription: 'Analyze content for security concerns',
      fullDescription:
        'Analyzes content for sensitive information, secrets, and security vulnerabilities.',
      category: 'content-security',
      complexity: 'moderate',
      tokenCost: { min: 1500, max: 3000 },
      hasCEMCPDirective: true, // Phase 4.3: Moderate tool - security analysis
      relatedTools: ['generate_content_masking', 'validate_content_masking'],
      keywords: ['security', 'content', 'analyze', 'secrets', 'sensitive'],
      requiresAI: true,
      inputSchema: {
        type: 'object',
        properties: {
          content: { type: 'string', description: 'Content to analyze' },
          filePath: { type: 'string', description: 'Or path to file' },
          strictMode: { type: 'boolean', default: false },
        },
      },
    });
    
    TOOL_CATALOG.set('generate_content_masking', {
      name: 'generate_content_masking',
      shortDescription: 'Generate masking rules for content',
      fullDescription: 'Generates content masking rules to protect sensitive information in outputs.',
      category: 'content-security',
      complexity: 'moderate',
      tokenCost: { min: 1000, max: 2500 },
      hasCEMCPDirective: true, // Phase 4.3: Moderate tool - masking rule generation
      relatedTools: ['analyze_content_security', 'apply_basic_content_masking'],
      keywords: ['masking', 'generate', 'rules', 'protection'],
      requiresAI: true,
      inputSchema: {
        type: 'object',
        properties: {
          content: { type: 'string' },
          maskingLevel: { type: 'string', enum: ['minimal', 'standard', 'aggressive'] },
        },
        required: ['content'],
      },
    });
    
    TOOL_CATALOG.set('apply_basic_content_masking', {
      name: 'apply_basic_content_masking',
      shortDescription: 'Apply basic content masking',
      fullDescription: 'Applies basic content masking using predefined patterns.',
      category: 'content-security',
      complexity: 'simple',
      tokenCost: { min: 200, max: 500 },
      hasCEMCPDirective: true, // Phase 4.3: Simple tool - single masking operation
      relatedTools: ['generate_content_masking', 'configure_custom_patterns'],
      keywords: ['masking', 'apply', 'basic', 'content'],
      requiresAI: false,
      inputSchema: {
        type: 'object',
        properties: {
          content: { type: 'string' },
        },
        required: ['content'],
      },
    });
    
    TOOL_CATALOG.set('configure_custom_patterns', {
      name: 'configure_custom_patterns',
      shortDescription: 'Configure custom masking patterns',
      fullDescription: 'Configures custom patterns for content masking.',
      category: 'content-security',
      complexity: 'simple',
      tokenCost: { min: 200, max: 500 },
      hasCEMCPDirective: true, // Phase 4.3: Simple tool - pattern configuration
      relatedTools: ['apply_basic_content_masking', 'validate_content_masking'],
      keywords: ['patterns', 'configure', 'custom', 'masking'],
      requiresAI: false,
      inputSchema: {
        type: 'object',
        properties: {
          patterns: { type: 'array', items: { type: 'object' } },
          name: { type: 'string' },
        },
        required: ['patterns'],
      },
    });
    
    TOOL_CATALOG.set('validate_content_masking', {
      name: 'validate_content_masking',
      shortDescription: 'Validate content masking effectiveness',
      fullDescription: 'Validates that content masking is properly applied and effective.',
      category: 'content-security',
      complexity: 'simple',
      tokenCost: { min: 300, max: 800 },
      hasCEMCPDirective: true, // Phase 4.3: Simple tool - validation operation
      relatedTools: ['apply_basic_content_masking', 'analyze_content_security'],
      keywords: ['validate', 'masking', 'check', 'verify'],
      requiresAI: false,
      inputSchema: {
        type: 'object',
        properties: {
          maskedContent: { type: 'string' },
          originalContent: { type: 'string' },
        },
        required: ['maskedContent'],
      },
    });
    
    TOOL_CATALOG.set('configure_output_masking', {
      name: 'configure_output_masking',
      shortDescription: 'Configure output masking settings',
      fullDescription: 'Configures global output masking settings and rules.',
      category: 'content-security',
      complexity: 'simple',
      tokenCost: { min: 200, max: 400 },
      hasCEMCPDirective: true, // Phase 4.3: Simple tool - settings configuration
      relatedTools: ['apply_basic_content_masking', 'configure_custom_patterns'],
      keywords: ['configure', 'output', 'masking', 'settings'],
      requiresAI: false,
      inputSchema: {
        type: 'object',
        properties: {
          enabled: { type: 'boolean' },
          level: { type: 'string', enum: ['minimal', 'standard', 'aggressive'] },
        },
      },
    });
    
    // ============================================================================
    // RESEARCH & INTEGRATION TOOLS
    // ============================================================================
    
    TOOL_CATALOG.set('perform_research', {
      name: 'perform_research',
      shortDescription: 'Perform research on a topic',
      fullDescription:
        'Performs comprehensive research on a given topic using web search and analysis.',
      category: 'research',
      complexity: 'complex',
      tokenCost: { min: 4000, max: 10000 },
      hasCEMCPDirective: true, // Phase 4.2: CE-MCP directive added
      relatedTools: ['incorporate_research', 'generate_research_questions'],
      keywords: ['research', 'search', 'investigate', 'topic'],
      requiresAI: true,
      inputSchema: {
        type: 'object',
        properties: {
          topic: { type: 'string', description: 'Research topic' },
          depth: { type: 'string', enum: ['quick', 'standard', 'deep'] },
          outputFormat: { type: 'string', enum: ['summary', 'detailed', 'structured'] },
        },
        required: ['topic'],
      },
    });
    
    TOOL_CATALOG.set('incorporate_research', {
      name: 'incorporate_research',
      shortDescription: 'Incorporate research findings',
      fullDescription: 'Incorporates research findings into project documentation or knowledge base.',
      category: 'research',
      complexity: 'moderate',
      tokenCost: { min: 2000, max: 4000 },
      hasCEMCPDirective: true, // Phase 4.3: Moderate tool - research integration
      relatedTools: ['perform_research', 'create_research_template'],
      keywords: ['research', 'incorporate', 'integrate', 'findings'],
      requiresAI: true,
      inputSchema: {
        type: 'object',
        properties: {
          researchId: { type: 'string' },
          targetPath: { type: 'string' },
        },
        required: ['researchId'],
      },
    });
    
    TOOL_CATALOG.set('generate_research_questions', {
      name: 'generate_research_questions',
      shortDescription: 'Generate research questions',
      fullDescription: 'Generates research questions based on project context and identified gaps.',
      category: 'research',
      complexity: 'moderate',
      tokenCost: { min: 1500, max: 3000 },
      hasCEMCPDirective: true, // Phase 4.3: Moderate tool - question generation
      relatedTools: ['perform_research', 'create_research_template'],
      keywords: ['research', 'questions', 'generate', 'gaps'],
      requiresAI: true,
      inputSchema: {
        type: 'object',
        properties: {
          context: { type: 'string' },
          focus: { type: 'array', items: { type: 'string' } },
        },
      },
    });
    
    TOOL_CATALOG.set('create_research_template', {
      name: 'create_research_template',
      shortDescription: 'Create research template',
      fullDescription: 'Creates a structured research template for a topic.',
      category: 'research',
      complexity: 'simple',
      tokenCost: { min: 500, max: 1000 },
      hasCEMCPDirective: true, // Phase 4.3: Simple tool - template generation
      relatedTools: ['perform_research', 'incorporate_research'],
      keywords: ['research', 'template', 'create', 'structure'],
      requiresAI: false,
      inputSchema: {
        type: 'object',
        properties: {
          topic: { type: 'string' },
          templateType: { type: 'string', enum: ['investigation', 'comparison', 'analysis'] },
        },
        required: ['topic'],
      },
    });
    
    TOOL_CATALOG.set('llm_web_search', {
      name: 'llm_web_search',
      shortDescription: 'Web search via LLM',
      fullDescription: 'Performs web searches with LLM-enhanced result analysis.',
      category: 'research',
      complexity: 'moderate',
      tokenCost: { min: 2000, max: 5000 },
      hasCEMCPDirective: true, // Phase 4.3: Moderate tool - LLM web search
      relatedTools: ['perform_research', 'llm_cloud_management'],
      keywords: ['search', 'web', 'llm', 'internet'],
      requiresAI: true,
      inputSchema: {
        type: 'object',
        properties: {
          query: { type: 'string', description: 'Search query' },
          maxResults: { type: 'number', default: 10 },
        },
        required: ['query'],
      },
    });
    
    TOOL_CATALOG.set('llm_cloud_management', {
      name: 'llm_cloud_management',
      shortDescription: 'Cloud management via LLM',
      fullDescription: 'Cloud resource management with LLM assistance.',
      category: 'research',
      complexity: 'complex',
      tokenCost: { min: 3000, max: 6000 },
      hasCEMCPDirective: true, // Phase 4.3: Complex tool - cloud management orchestration
      relatedTools: ['llm_web_search', 'llm_database_management'],
      keywords: ['cloud', 'management', 'llm', 'aws', 'gcp', 'azure'],
      requiresAI: true,
      inputSchema: {
        type: 'object',
        properties: {
          operation: { type: 'string' },
          provider: { type: 'string', enum: ['aws', 'gcp', 'azure'] },
        },
        required: ['operation'],
      },
    });
    
    TOOL_CATALOG.set('llm_database_management', {
      name: 'llm_database_management',
      shortDescription: 'Database management via LLM',
      fullDescription: 'Database operations with LLM assistance.',
      category: 'research',
      complexity: 'complex',
      tokenCost: { min: 2500, max: 5000 },
      hasCEMCPDirective: true, // Phase 4.3: Complex tool - database management orchestration
      relatedTools: ['llm_cloud_management', 'llm_web_search'],
      keywords: ['database', 'management', 'llm', 'sql', 'nosql'],
      requiresAI: true,
      inputSchema: {
        type: 'object',
        properties: {
          operation: { type: 'string' },
          databaseType: { type: 'string' },
        },
        required: ['operation'],
      },
    });
    
    // ============================================================================
    // DEPLOYMENT & OPERATIONS TOOLS
    // ============================================================================
    
    TOOL_CATALOG.set('deployment_readiness', {
      name: 'deployment_readiness',
      shortDescription: 'Check deployment readiness',
      fullDescription: 'Validates deployment readiness with zero-tolerance for critical failures.',
      category: 'deployment',
      complexity: 'complex',
      tokenCost: { min: 2000, max: 4000 },
      hasCEMCPDirective: true,
      relatedTools: ['smart_git_push', 'analyze_deployment_progress'],
      keywords: ['deployment', 'readiness', 'validation', 'check'],
      requiresAI: true,
      inputSchema: {
        type: 'object',
        properties: {
          projectPath: { type: 'string' },
          environment: { type: 'string', enum: ['development', 'staging', 'production'] },
          strictMode: { type: 'boolean', default: true },
        },
        required: ['projectPath'],
      },
    });
    
    TOOL_CATALOG.set('smart_git_push', {
      name: 'smart_git_push',
      shortDescription: 'Intelligent git push operations',
      fullDescription:
        'Performs intelligent git operations with pre-push validation and conflict detection.',
      category: 'deployment',
      complexity: 'moderate',
      tokenCost: { min: 1000, max: 2500 },
      hasCEMCPDirective: true, // Phase 4.3: Moderate tool - git operations
      relatedTools: ['deployment_readiness', 'analyze_deployment_progress'],
      keywords: ['git', 'push', 'smart', 'deployment'],
      requiresAI: false,
      inputSchema: {
        type: 'object',
        properties: {
          branch: { type: 'string' },
          force: { type: 'boolean', default: false },
          runTests: { type: 'boolean', default: true },
        },
      },
    });
    
    TOOL_CATALOG.set('bootstrap_validation_loop', {
      name: 'bootstrap_validation_loop',
      shortDescription: 'Bootstrap validation loop for deployment',
      fullDescription: 'Initiates a validation loop for deployment using validated patterns.',
      category: 'deployment',
      complexity: 'complex',
      tokenCost: { min: 3000, max: 6000 },
      hasCEMCPDirective: true, // Phase 4.3: Complex tool - state machine validation
      relatedTools: ['deployment_readiness', 'generate_deployment_guidance'],
      keywords: ['bootstrap', 'validation', 'loop', 'deployment', 'patterns'],
      requiresAI: true,
      inputSchema: {
        type: 'object',
        properties: {
          projectPath: { type: 'string' },
          pattern: { type: 'string' },
        },
        required: ['projectPath'],
      },
    });
    
    TOOL_CATALOG.set('analyze_deployment_progress', {
      name: 'analyze_deployment_progress',
      shortDescription: 'Analyze deployment progress',
      fullDescription: 'Analyzes the progress of ongoing deployments.',
      category: 'deployment',
      complexity: 'moderate',
      tokenCost: { min: 1500, max: 3000 },
      hasCEMCPDirective: true, // Phase 4.3: Moderate tool - deployment tracking
      relatedTools: ['deployment_readiness', 'generate_deployment_guidance'],
      keywords: ['deployment', 'progress', 'analyze', 'status'],
      requiresAI: false,
      inputSchema: {
        type: 'object',
        properties: {
          deploymentId: { type: 'string' },
          includeMetrics: { type: 'boolean', default: true },
        },
      },
    });
    
    TOOL_CATALOG.set('generate_deployment_guidance', {
      name: 'generate_deployment_guidance',
      shortDescription: 'Generate deployment guidance',
      fullDescription:
        'Generates deployment guidance based on project configuration and best practices.',
      category: 'deployment',
      complexity: 'moderate',
      tokenCost: { min: 2000, max: 4000 },
      hasCEMCPDirective: true, // Phase 4.3: Moderate tool - guidance generation
      relatedTools: ['deployment_readiness', 'bootstrap_validation_loop'],
      keywords: ['deployment', 'guidance', 'generate', 'best-practices'],
      requiresAI: true,
      inputSchema: {
        type: 'object',
        properties: {
          projectPath: { type: 'string' },
          targetEnvironment: { type: 'string' },
        },
        required: ['projectPath'],
      },
    });
    
    TOOL_CATALOG.set('troubleshoot_guided_workflow', {
      name: 'troubleshoot_guided_workflow',
      shortDescription: 'Guided troubleshooting workflow',
      fullDescription: 'Provides guided troubleshooting for deployment and operational issues.',
      category: 'deployment',
      complexity: 'complex',
      tokenCost: { min: 3000, max: 7000 },
      hasCEMCPDirective: true, // Phase 4.2: CE-MCP directive added
      relatedTools: ['deployment_readiness', 'analyze_deployment_progress'],
      keywords: ['troubleshoot', 'guided', 'workflow', 'issues'],
      requiresAI: true,
      inputSchema: {
        type: 'object',
        properties: {
          issue: { type: 'string', description: 'Issue description' },
          context: { type: 'string' },
        },
        required: ['issue'],
      },
    });
    
    // ============================================================================
    // MEMORY & STATE TOOLS
    // ============================================================================
    
    TOOL_CATALOG.set('memory_loading', {
      name: 'memory_loading',
      shortDescription: 'Load memory context',
      fullDescription: 'Loads memory context from previous sessions.',
      category: 'memory',
      complexity: 'simple',
      tokenCost: { min: 500, max: 2000 },
      hasCEMCPDirective: true, // Phase 4.3: Simple tool - memory retrieval
      relatedTools: ['expand_memory', 'query_conversation_history'],
      keywords: ['memory', 'load', 'context', 'session'],
      requiresAI: false,
      inputSchema: {
        type: 'object',
        properties: {
          sessionId: { type: 'string' },
          maxItems: { type: 'number', default: 100 },
        },
      },
    });
    
    TOOL_CATALOG.set('expand_memory', {
      name: 'expand_memory',
      shortDescription: 'Expand memory with new context',
      fullDescription: 'Expands memory with additional context information.',
      category: 'memory',
      complexity: 'simple',
      tokenCost: { min: 300, max: 800 },
      hasCEMCPDirective: true, // Phase 4.3: Simple tool - memory storage
      relatedTools: ['memory_loading', 'get_memory_stats'],
      keywords: ['memory', 'expand', 'add', 'context'],
      requiresAI: false,
      inputSchema: {
        type: 'object',
        properties: {
          key: { type: 'string' },
          value: { type: 'object' },
        },
        required: ['key', 'value'],
      },
    });
    
    TOOL_CATALOG.set('query_conversation_history', {
      name: 'query_conversation_history',
      shortDescription: 'Query conversation history',
      fullDescription: 'Queries the conversation history for relevant context.',
      category: 'memory',
      complexity: 'simple',
      tokenCost: { min: 500, max: 1500 },
      hasCEMCPDirective: true, // Phase 4.3: Simple tool - history query
      relatedTools: ['get_conversation_snapshot', 'memory_loading'],
      keywords: ['conversation', 'history', 'query', 'search'],
      requiresAI: false,
      inputSchema: {
        type: 'object',
        properties: {
          query: { type: 'string' },
          limit: { type: 'number', default: 20 },
        },
      },
    });
    
    TOOL_CATALOG.set('get_conversation_snapshot', {
      name: 'get_conversation_snapshot',
      shortDescription: 'Get conversation snapshot',
      fullDescription: 'Gets a snapshot of the current conversation state.',
      category: 'memory',
      complexity: 'simple',
      tokenCost: { min: 300, max: 800 },
      hasCEMCPDirective: true, // Phase 4.3: Simple tool - state snapshot
      relatedTools: ['query_conversation_history', 'get_memory_stats'],
      keywords: ['conversation', 'snapshot', 'state'],
      requiresAI: false,
      inputSchema: {
        type: 'object',
        properties: {
          includeMetadata: { type: 'boolean', default: false },
        },
      },
    });
    
    TOOL_CATALOG.set('get_memory_stats', {
      name: 'get_memory_stats',
      shortDescription: 'Get memory statistics',
      fullDescription: 'Gets statistics about memory usage and storage.',
      category: 'memory',
      complexity: 'simple',
      tokenCost: { min: 200, max: 400 },
      hasCEMCPDirective: true, // Phase 4.3: Simple tool - stats retrieval
      relatedTools: ['memory_loading', 'expand_memory'],
      keywords: ['memory', 'stats', 'statistics', 'usage'],
      requiresAI: false,
      inputSchema: {
        type: 'object',
        properties: {
          detailed: { type: 'boolean', default: false },
        },
      },
    });
    
    TOOL_CATALOG.set('expand_analysis_section', {
      name: 'expand_analysis_section',
      shortDescription: 'Expand analysis section',
      fullDescription: 'Expands a specific section of analysis with more detail.',
      category: 'memory',
      complexity: 'moderate',
      tokenCost: { min: 1500, max: 3000 },
      hasCEMCPDirective: true, // Phase 4.3: Moderate tool - section expansion
      relatedTools: ['analyze_project_ecosystem', 'memory_loading'],
      keywords: ['expand', 'analysis', 'section', 'detail'],
      requiresAI: true,
      inputSchema: {
        type: 'object',
        properties: {
          sectionId: { type: 'string' },
          depth: { type: 'string', enum: ['summary', 'detailed', 'comprehensive'] },
        },
        required: ['sectionId'],
      },
    });
    
    // ============================================================================
    // FILE SYSTEM TOOLS
    // ============================================================================
    
    TOOL_CATALOG.set('read_file', {
      name: 'read_file',
      shortDescription: 'Read file contents',
      fullDescription: 'Reads the contents of a file.',
      category: 'file-system',
      complexity: 'simple',
      tokenCost: { min: 100, max: 5000 },
      hasCEMCPDirective: true, // Phase 4.3: Simple tool - file read operation
      relatedTools: ['write_file', 'read_directory'],
      keywords: ['file', 'read', 'contents'],
      requiresAI: false,
      inputSchema: {
        type: 'object',
        properties: {
          path: { type: 'string', description: 'Path to file' },
        },
        required: ['path'],
      },
    });
    
    TOOL_CATALOG.set('write_file', {
      name: 'write_file',
      shortDescription: 'Write file contents',
      fullDescription: 'Writes content to a file.',
      category: 'file-system',
      complexity: 'simple',
      tokenCost: { min: 100, max: 1000 },
      hasCEMCPDirective: true, // Phase 4.3: Simple tool - file write operation
      relatedTools: ['read_file', 'list_directory'],
      keywords: ['file', 'write', 'save'],
      requiresAI: false,
      inputSchema: {
        type: 'object',
        properties: {
          path: { type: 'string', description: 'Path to file' },
          content: { type: 'string', description: 'Content to write' },
        },
        required: ['path', 'content'],
      },
    });
    
    TOOL_CATALOG.set('read_directory', {
      name: 'read_directory',
      shortDescription: 'Read directory contents',
      fullDescription: 'Lists contents of a directory.',
      category: 'file-system',
      complexity: 'simple',
      tokenCost: { min: 100, max: 1000 },
      hasCEMCPDirective: true, // Phase 4.3: Simple tool - directory read
      relatedTools: ['read_file', 'list_directory'],
      keywords: ['directory', 'read', 'list'],
      requiresAI: false,
      inputSchema: {
        type: 'object',
        properties: {
          path: { type: 'string', description: 'Path to directory' },
          recursive: { type: 'boolean', default: false },
        },
        required: ['path'],
      },
    });
    
    TOOL_CATALOG.set('list_directory', {
      name: 'list_directory',
      shortDescription: 'List directory contents',
      fullDescription: 'Lists files and directories in a path.',
      category: 'file-system',
      complexity: 'simple',
      tokenCost: { min: 100, max: 500 },
      hasCEMCPDirective: true, // Phase 4.3: Simple tool - directory listing
      relatedTools: ['read_directory', 'read_file'],
      keywords: ['directory', 'list', 'files'],
      requiresAI: false,
      inputSchema: {
        type: 'object',
        properties: {
          path: { type: 'string', description: 'Path to directory' },
        },
        required: ['path'],
      },
    });
    
    TOOL_CATALOG.set('list_roots', {
      name: 'list_roots',
      shortDescription: 'List root directories',
      fullDescription: 'Lists configured root directories.',
      category: 'file-system',
      complexity: 'simple',
      tokenCost: { min: 50, max: 200 },
      hasCEMCPDirective: true, // Phase 4.3: Simple tool - root listing
      relatedTools: ['read_directory', 'list_directory'],
      keywords: ['roots', 'list', 'directories'],
      requiresAI: false,
      inputSchema: {
        type: 'object',
        properties: {},
      },
    });
    
    // ============================================================================
    // RULES & VALIDATION TOOLS
    // ============================================================================
    
    TOOL_CATALOG.set('generate_rules', {
      name: 'generate_rules',
      shortDescription: 'Generate validation rules',
      fullDescription: 'Generates validation rules based on project patterns and best practices.',
      category: 'rules',
      complexity: 'complex',
      tokenCost: { min: 3000, max: 6000 },
      hasCEMCPDirective: true,
      relatedTools: ['validate_rules', 'create_rule_set'],
      keywords: ['rules', 'generate', 'validation', 'patterns'],
      requiresAI: true,
      inputSchema: {
        type: 'object',
        properties: {
          projectPath: { type: 'string' },
          ruleType: { type: 'string', enum: ['code', 'architecture', 'deployment'] },
          outputFormat: { type: 'string', enum: ['json', 'yaml', 'typescript'] },
        },
        required: ['projectPath'],
      },
    });
    
    TOOL_CATALOG.set('validate_rules', {
      name: 'validate_rules',
      shortDescription: 'Validate rules against codebase',
      fullDescription: 'Validates rules against the codebase and reports violations.',
      category: 'rules',
      complexity: 'moderate',
      tokenCost: { min: 1500, max: 3000 },
      hasCEMCPDirective: true, // Phase 4.3: Moderate tool - rule validation
      relatedTools: ['generate_rules', 'create_rule_set'],
      keywords: ['rules', 'validate', 'check', 'violations'],
      requiresAI: false,
      inputSchema: {
        type: 'object',
        properties: {
          rulePath: { type: 'string' },
          targetPath: { type: 'string' },
        },
        required: ['rulePath'],
      },
    });
    
    TOOL_CATALOG.set('create_rule_set', {
      name: 'create_rule_set',
      shortDescription: 'Create rule set',
      fullDescription: 'Creates a new rule set configuration.',
      category: 'rules',
      complexity: 'simple',
      tokenCost: { min: 500, max: 1000 },
      hasCEMCPDirective: true, // Phase 4.3: Simple tool - rule set creation
      relatedTools: ['generate_rules', 'validate_rules'],
      keywords: ['rules', 'create', 'set', 'configuration'],
      requiresAI: false,
      inputSchema: {
        type: 'object',
        properties: {
          name: { type: 'string' },
          rules: { type: 'array', items: { type: 'object' } },
        },
        required: ['name', 'rules'],
      },
    });
    
    // ============================================================================
    // WORKFLOW & GUIDANCE TOOLS
    // ============================================================================
    
    TOOL_CATALOG.set('get_workflow_guidance', {
      name: 'get_workflow_guidance',
      shortDescription: 'Get workflow guidance',
      fullDescription: 'Provides guidance for specific workflows.',
      category: 'workflow',
      complexity: 'moderate',
      tokenCost: { min: 1500, max: 3000 },
      hasCEMCPDirective: true, // Phase 4.3: Moderate tool - workflow guidance
      relatedTools: ['get_development_guidance', 'mcp_planning'],
      keywords: ['workflow', 'guidance', 'help', 'process'],
      requiresAI: true,
      inputSchema: {
        type: 'object',
        properties: {
          workflowType: { type: 'string' },
          context: { type: 'string' },
        },
        required: ['workflowType'],
      },
    });
    
    TOOL_CATALOG.set('get_development_guidance', {
      name: 'get_development_guidance',
      shortDescription: 'Get development guidance',
      fullDescription: 'Provides development guidance and best practices.',
      category: 'workflow',
      complexity: 'moderate',
      tokenCost: { min: 1500, max: 3000 },
      hasCEMCPDirective: true, // Phase 4.3: Moderate tool - development guidance
      relatedTools: ['get_workflow_guidance', 'mcp_planning'],
      keywords: ['development', 'guidance', 'best-practices'],
      requiresAI: true,
      inputSchema: {
        type: 'object',
        properties: {
          topic: { type: 'string' },
          level: { type: 'string', enum: ['beginner', 'intermediate', 'advanced'] },
        },
        required: ['topic'],
      },
    });
    
    TOOL_CATALOG.set('mcp_planning', {
      name: 'mcp_planning',
      shortDescription: 'MCP planning assistant',
      fullDescription: 'Assists with MCP server planning and design.',
      category: 'workflow',
      complexity: 'complex',
      tokenCost: { min: 3000, max: 6000 },
      hasCEMCPDirective: true, // Phase 4.2: CE-MCP directive added
      relatedTools: ['get_workflow_guidance', 'tool_chain_orchestrator'],
      keywords: ['mcp', 'planning', 'design', 'server'],
      requiresAI: true,
      inputSchema: {
        type: 'object',
        properties: {
          goal: { type: 'string' },
          constraints: { type: 'array', items: { type: 'string' } },
        },
        required: ['goal'],
      },
    });
    
    TOOL_CATALOG.set('tool_chain_orchestrator', {
      name: 'tool_chain_orchestrator',
      shortDescription: 'Orchestrate tool chains',
      fullDescription: 'Orchestrates multiple tools in a workflow chain.',
      category: 'workflow',
      complexity: 'complex',
      tokenCost: { min: 2000, max: 5000 },
      hasCEMCPDirective: true, // Phase 4.3: Complex tool - multi-tool orchestration
      relatedTools: ['mcp_planning', 'get_workflow_guidance'],
      keywords: ['orchestrator', 'tools', 'chain', 'workflow'],
      requiresAI: true,
      inputSchema: {
        type: 'object',
        properties: {
          chain: { type: 'array', items: { type: 'object' } },
          mode: { type: 'string', enum: ['sequential', 'parallel'] },
        },
        required: ['chain'],
      },
    });
    
    TOOL_CATALOG.set('request_action_confirmation', {
      name: 'request_action_confirmation',
      shortDescription: 'Request action confirmation',
      fullDescription: 'Requests user confirmation for actions.',
      category: 'workflow',
      complexity: 'simple',
      tokenCost: { min: 100, max: 300 },
      hasCEMCPDirective: true, // Phase 4.3: Simple tool - confirmation request
      relatedTools: ['tool_chain_orchestrator'],
      keywords: ['confirmation', 'request', 'action', 'approve'],
      requiresAI: false,
      inputSchema: {
        type: 'object',
        properties: {
          action: { type: 'string', description: 'Action to confirm' },
          details: { type: 'string' },
        },
        required: ['action'],
      },
    });
    
    // ============================================================================
    // UTILITY TOOLS
    // ============================================================================
    
    TOOL_CATALOG.set('manage_cache', {
      name: 'manage_cache',
      shortDescription: 'Manage cache operations',
      fullDescription: 'Manages cache operations including clear, stats, and cleanup.',
      category: 'utility',
      complexity: 'simple',
      tokenCost: { min: 100, max: 500 },
      hasCEMCPDirective: true, // Phase 4.3: Simple tool - cache management
      relatedTools: ['get_server_context', 'get_memory_stats'],
      keywords: ['cache', 'manage', 'clear', 'cleanup'],
      requiresAI: false,
      inputSchema: {
        type: 'object',
        properties: {
          action: { type: 'string', enum: ['clear', 'stats', 'cleanup', 'invalidate'] },
          key: { type: 'string' },
        },
        required: ['action'],
      },
    });
    
    TOOL_CATALOG.set('check_ai_execution_status', {
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions debugging purposes but doesn't specify what information is returned, whether it requires special permissions, if it's read-only or has side effects, or any rate limits. This leaves significant gaps in understanding the tool's behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized for a zero-parameter tool and front-loads the essential information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter tool with no output schema, the description provides basic purpose and context but lacks details about what specific information is returned, format of output, or how it differs from similar status-checking tools. Given the absence of annotations and output schema, more behavioral context would be helpful.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters with 100% schema description coverage, so the schema already fully documents the input requirements. The description appropriately doesn't add parameter information, maintaining focus on the tool's purpose rather than redundant details.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose as checking AI execution configuration and status for debugging prompt-only mode issues. It specifies the verb ('check') and resource ('AI execution configuration and status'), but doesn't distinguish it from sibling tools like 'get_server_context' or 'get_memory_stats' that might also provide status information.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description mentions 'for debugging prompt-only mode issues,' which provides some context about when to use the tool. However, it doesn't specify when NOT to use it or suggest alternatives among the many sibling tools, leaving the agent with incomplete guidance on tool selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/tosin2013/mcp-adr-analysis-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server