Hi-AI

Instructions

Implementation Reference

• src/tools/prompt/enhancePrompt.ts:27-132 (handler)

  The main handler function that executes the enhance_prompt tool. It analyzes the input prompt for clarity, specificity, and context needs, then constructs an enhanced prompt with structured sections like Objective, Background, Requirements, and Quality Criteria.

  export async function enhancePrompt(args: { prompt: string; context?: string; enhancement_type?: string }): Promise<ToolResult> {
    const { prompt, context = '', enhancement_type = 'all' } = args;
    
    // Enhancement logic
    const enhancements: Record<string, string[]> = {
      clarity: [],
      specificity: [],
      context: [],
      structure: []
    };
    
    // Analyze original prompt
    const promptLength = prompt.length;
    const hasQuestion = prompt.includes('?');
    const hasSpecificTerms = /\b(implement|develop|modify|analyze|debug|refactor)\b/i.test(prompt);
    
    // Apply enhancements based on type
    if (enhancement_type === 'clarity' || enhancement_type === 'all') {
      if (promptLength < 20) {
        enhancements.clarity.push('Add more specific description');
      }
      if (!hasQuestion && !hasSpecificTerms) {
        enhancements.clarity.push('Convert to clear request or question format');
      }
      if (hasQuestion && promptLength > 100) {
        enhancements.clarity.push('Question is clear and detailed');
      }
    }
    
    if (enhancement_type === 'specificity' || enhancement_type === 'all') {
      if (!prompt.match(/\b(language|framework|library|version)\b/i)) {
        enhancements.specificity.push('Specify tech stack');
      }
      if (!prompt.match(/\b(input|output|result|format)\b/i)) {
        enhancements.specificity.push('Define expected input/output');
      }
    }
    
    if (enhancement_type === 'context' || enhancement_type === 'all') {
      if (!prompt.match(/\b(purpose|reason|background|situation)\b/i)) {
        enhancements.context.push('Add task purpose and background');
      }
      if (context) {
        enhancements.context.push('Integrate provided context');
      }
    }
    
    // Generate enhanced prompt
    let enhancedPrompt = prompt;
    
    // Build enhanced version
    const components = [];
    
    // Add objective
    components.push(`**Objective**: ${prompt}`);
    
    // Add context if provided
    if (context) {
      components.push(`**Background**: ${context}`);
    }
    
    // Add specific requirements based on analysis
    const requirements = [];
    if (enhancements.specificity.includes('Specify tech stack')) {
      requirements.push('- Please specify the language/framework to use');
    }
    if (enhancements.specificity.includes('Define expected input/output')) {
      requirements.push('- Please describe expected input and output formats');
    }
    
    if (requirements.length > 0) {
      components.push(`**Requirements**:\n${requirements.join('\n')}`);
    }
    
    // Add quality considerations
    const quality = [
      '- Include error handling',
      '- Testable structure',
      '- Extensible design',
      '- Performance considerations',
      '- Clear documentation',
      '- Follow best practices',
      '- Code readability',
      '- Maintainability'
    ];
    components.push(`**Quality Criteria**:\n${quality.join('\n')}`);
    
    enhancedPrompt = components.join('\n\n');
    
    const result = {
      action: 'enhance_prompt',
      original: prompt,
      enhanced: enhancedPrompt,
      enhancements,
      improvements: [
        enhancements.clarity.length > 0 ? `Clarity improved (${enhancements.clarity.length} items)` : null,
        enhancements.specificity.length > 0 ? `Specificity added (${enhancements.specificity.length} items)` : null,
        enhancements.context.length > 0 ? `Context enriched (${enhancements.context.length} items)` : null
      ].filter(Boolean),
      status: 'success'
    };
    
    return {
      content: [{ type: 'text', text: `Original: ${prompt}\n\nEnhanced:\n${enhancedPrompt}\n\nImprovements: ${result.improvements.join(', ')}` }]
    };
  }

• src/tools/prompt/enhancePrompt.ts:5-25 (schema)

  ToolDefinition object defining the name, description, input schema (prompt required, optional context and enhancement_type), and annotations for the enhance_prompt tool.

  export const enhancePromptDefinition: ToolDefinition = {
    name: 'enhance_prompt',
    description: 'be specific|more detail|clarify|elaborate|vague|enhance|improve prompt - Transform vague requests into clear, actionable prompts',
    inputSchema: {
      type: 'object',
      properties: {
        prompt: { type: 'string', description: 'Original prompt to enhance' },
        context: { type: 'string', description: 'Additional context or project information' },
        enhancement_type: {
          type: 'string',
          enum: ['clarity', 'specificity', 'context', 'all'],
          description: 'Type of enhancement (default: all)'
        }
      },
      required: ['prompt']
    },
    annotations: {
      title: 'Enhance Prompt',
      audience: ['user', 'assistant']
    }
  };

• src/index.ts:104-160 (registration)

  The enhancePromptDefinition is included in the tools array (specifically at line 151), which is used by the MCP server for listing available tools.

  const tools: ToolDefinition[] = [
    // Time Utility Tools
    getCurrentTimeDefinition,
  
    // Semantic Code Analysis Tools (Serena-inspired)
    findSymbolDefinition,
    findReferencesDefinition,
  
    // Sequential Thinking Tools
    createThinkingChainDefinition,
    analyzeProblemDefinition,
    stepByStepAnalysisDefinition,
    breakDownProblemDefinition,
    thinkAloudProcessDefinition,
    formatAsPlanDefinition,
  
    // Browser Development Tools
    monitorConsoleLogsDefinition,
    inspectNetworkRequestsDefinition,
  
    // Memory Management Tools
    saveMemoryDefinition,
    recallMemoryDefinition,
    listMemoriesDefinition,
    deleteMemoryDefinition,
    searchMemoriesDefinition,
    updateMemoryDefinition,
    autoSaveContextDefinition,
    restoreSessionContextDefinition,
    prioritizeMemoryDefinition,
    startSessionDefinition,
  
    // Convention Tools
    getCodingGuideDefinition,
    applyQualityRulesDefinition,
    validateCodeQualityDefinition,
    analyzeComplexityDefinition,
    checkCouplingCohesionDefinition,
    suggestImprovementsDefinition,
  
    // Planning Tools
    generatePrdDefinition,
    createUserStoriesDefinition,
    analyzeRequirementsDefinition,
    featureRoadmapDefinition,
  
    // Prompt Enhancement Tools
    enhancePromptDefinition,
    analyzePromptDefinition,
    enhancePromptGeminiDefinition,
  
    // Reasoning Tools
    applyReasoningFrameworkDefinition,
  
    // UI Preview Tools
    previewUiAsciiDefinition
  ];

• src/index.ts:603-700 (registration)

  The switch statement in executeToolCall dispatches 'enhance_prompt' calls to the enhancePrompt handler function (lines 682-683). This is the runtime registration for tool execution.

  async function executeToolCall(name: string, args: unknown): Promise<CallToolResult> {
    switch (name) {
      // Time Utility Tools
      case 'get_current_time':
        return await getCurrentTime(args as any) as CallToolResult;
  
      // Semantic Code Analysis Tools
      case 'find_symbol':
        return await findSymbol(args as any) as CallToolResult;
      case 'find_references':
        return await findReferences(args as any) as CallToolResult;
  
      // Sequential Thinking Tools
      case 'create_thinking_chain':
        return await createThinkingChain(args as any) as CallToolResult;
      case 'analyze_problem':
        return await analyzeProblem(args as any) as CallToolResult;
      case 'step_by_step_analysis':
        return await stepByStepAnalysis(args as any) as CallToolResult;
      case 'break_down_problem':
        return await breakDownProblem(args as any) as CallToolResult;
      case 'think_aloud_process':
        return await thinkAloudProcess(args as any) as CallToolResult;
      case 'format_as_plan':
        return await formatAsPlan(args as any) as CallToolResult;
  
      // Browser Development Tools
      case 'monitor_console_logs':
        return await monitorConsoleLogs(args as any) as CallToolResult;
      case 'inspect_network_requests':
        return await inspectNetworkRequests(args as any) as CallToolResult;
  
      // Memory Management Tools
      case 'save_memory':
        return await saveMemory(args as any) as CallToolResult;
      case 'recall_memory':
        return await recallMemory(args as any) as CallToolResult;
      case 'list_memories':
        return await listMemories(args as any) as CallToolResult;
      case 'delete_memory':
        return await deleteMemory(args as any) as CallToolResult;
      case 'search_memories':
        return await searchMemoriesHandler(args as any) as CallToolResult;
      case 'update_memory':
        return await updateMemory(args as any) as CallToolResult;
      case 'auto_save_context':
        return await autoSaveContext(args as any) as CallToolResult;
      case 'restore_session_context':
        return await restoreSessionContext(args as any) as CallToolResult;
      case 'prioritize_memory':
        return await prioritizeMemory(args as any) as CallToolResult;
      case 'start_session':
        return await startSession(args as any) as CallToolResult;
  
      // Convention Tools
      case 'get_coding_guide':
        return await getCodingGuide(args as any) as CallToolResult;
      case 'apply_quality_rules':
        return await applyQualityRules(args as any) as CallToolResult;
      case 'validate_code_quality':
        return await validateCodeQuality(args as any) as CallToolResult;
      case 'analyze_complexity':
        return await analyzeComplexity(args as any) as CallToolResult;
      case 'check_coupling_cohesion':
        return await checkCouplingCohesion(args as any) as CallToolResult;
      case 'suggest_improvements':
        return await suggestImprovements(args as any) as CallToolResult;
  
      // Planning Tools
      case 'generate_prd':
        return await generatePrd(args as any) as CallToolResult;
      case 'create_user_stories':
        return await createUserStories(args as any) as CallToolResult;
      case 'analyze_requirements':
        return await analyzeRequirements(args as any) as CallToolResult;
      case 'feature_roadmap':
        return await featureRoadmap(args as any) as CallToolResult;
  
      // Prompt Enhancement Tools
      case 'enhance_prompt':
        return await enhancePrompt(args as any) as CallToolResult;
      case 'analyze_prompt':
        return await analyzePrompt(args as any) as CallToolResult;
      case 'enhance_prompt_gemini':
        return await enhancePromptGemini(args as any) as CallToolResult;
  
      // Reasoning Tools
      case 'apply_reasoning_framework':
        return await applyReasoningFramework(args as any) as CallToolResult;
  
      // UI Preview Tools
      case 'preview_ui_ascii':
        return await previewUiAscii(args as any) as CallToolResult;
  
      default:
        throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
    }
  }

• src/index.ts:74-75 (registration)

  Import statement bringing in the enhancePrompt handler and its definition from the implementation file.

  import { enhancePrompt, enhancePromptDefinition } from './tools/prompt/enhancePrompt.js';
  import { enhancePromptGemini, enhancePromptGeminiDefinition } from './tools/prompt/enhancePromptGemini.js';