Hi-AI

Instructions

Implementation Reference

• src/tools/thinking/formatAsPlan.ts:28-84 (handler)

  The core handler function for 'format_as_plan' tool. Parses input content into actionable steps, assigns priorities and time estimates, formats with checkboxes, computes totals, and returns structured ToolResult.

  export async function formatAsPlan(args: { content: string; priority?: string; includeTimeEstimates?: boolean; includeCheckboxes?: boolean }): Promise<ToolResult> {
    const { content: planContent, priority = 'medium', includeTimeEstimates = true, includeCheckboxes = true } = args;
    
    // Parse content into actionable steps
    const sentences = planContent.split(/[.!?]+/).filter(s => s.trim().length > 10);
    const planSteps = sentences.map((sentence, index) => {
      const stepNumber = index + 1;
      const cleanSentence = sentence.trim();
      
      // Estimate time based on content complexity
      let timeEstimate = '5min';
      if (cleanSentence.length > 100) timeEstimate = '15min';
      else if (cleanSentence.length > 50) timeEstimate = '10min';
      
      // Detect priority keywords
      let stepPriority = priority;
      if (cleanSentence.match(/urgent|critical|important|first|must/i)) stepPriority = 'high';
      else if (cleanSentence.match(/later|eventually|nice|optional/i)) stepPriority = 'low';
      
      // Format step
      let formattedStep = includeCheckboxes ? `${stepNumber}. □ ` : `${stepNumber}. `;
      formattedStep += cleanSentence;
      if (includeTimeEstimates) formattedStep += ` (${stepPriority.toUpperCase()}, ${timeEstimate})`;
      
      return {
        number: stepNumber,
        content: cleanSentence,
        priority: stepPriority,
        timeEstimate,
        formatted: formattedStep
      };
    });
    
    // Calculate total time
    const totalMinutes = planSteps.reduce((total: number, step: any) => {
      const minutes = parseInt(step.timeEstimate.replace('min', ''));
      return total + minutes;
    }, 0);
    
    const planResult = {
      action: 'format_as_plan',
      originalContent: planContent,
      formattedPlan: planSteps.map((s: any) => s.formatted).join('\n'),
      steps: planSteps.length,
      totalEstimatedTime: `${totalMinutes} minutes`,
      breakdown: {
        high: planSteps.filter((s: any) => s.priority === 'high').length,
        medium: planSteps.filter((s: any) => s.priority === 'medium').length,
        low: planSteps.filter((s: any) => s.priority === 'low').length
      },
      status: 'success'
    };
    
    return {
      content: [{ type: 'text', text: `${planResult.formattedPlan}\n\nTotal: ${planResult.totalEstimatedTime} | Priority: ${planResult.breakdown.high}H ${planResult.breakdown.medium}M ${planResult.breakdown.low}L` }]
    };
  }

• src/tools/thinking/formatAsPlan.ts:5-26 (schema)

  ToolDefinition for 'format_as_plan' including name, description, inputSchema with properties for content, priority, time estimates, checkboxes, and annotations.

  export const formatAsPlanDefinition: ToolDefinition = {
    name: 'format_as_plan',
    description: '계획으로|정리해줘|체크리스트|format as plan|make a plan|organize this|checklist - Format content into clear plans',
    inputSchema: {
      type: 'object',
      properties: {
        content: { type: 'string', description: 'Content to format as a plan' },
        priority: { type: 'string', description: 'Default priority level', enum: ['high', 'medium', 'low'] },
        includeTimeEstimates: { type: 'boolean', description: 'Include time estimates for each step' },
        includeCheckboxes: { type: 'boolean', description: 'Include checkboxes for tracking progress' }
      },
      required: ['content']
    },
    annotations: {
      title: 'Format as Plan',
      audience: ['user', 'assistant'],
      readOnlyHint: true,
      destructiveHint: false,
      idempotentHint: true,
      openWorldHint: false
    }
  };

• src/index.ts:88-145 (registration)

  Registration of formatAsPlanDefinition in the tools array used for ListToolsRequest.

  const tools = [
    // Core Utilities (2)
    getCurrentTimeDefinition,
    previewUiAsciiDefinition,
  
    // Memory Management - Basic (6)
    saveMemoryDefinition,
    recallMemoryDefinition,
    updateMemoryDefinition,
    deleteMemoryDefinition,
    listMemoriesDefinition,
    prioritizeMemoryDefinition,
  
    // Memory Management - Graph (4) - v2.0 NEW
    linkMemoriesDefinition,
    getMemoryGraphDefinition,
    searchMemoriesAdvancedDefinition,
    createMemoryTimelineDefinition,
  
    // Memory Management - Session Context (1) - v2.1 NEW
    getSessionContextDefinition,
  
    // Code Analysis - Semantic (2)
    findSymbolDefinition,
    findReferencesDefinition,
  
    // Code Analysis - Advanced (1) - v2.0 NEW
    analyzeDependencyGraphDefinition,
  
    // Code Quality (6)
    getCodingGuideDefinition,
    applyQualityRulesDefinition,
    validateCodeQualityDefinition,
    analyzeComplexityDefinition,
    checkCouplingCohesionDefinition,
    suggestImprovementsDefinition,
  
    // Thinking & Planning (8)
    createThinkingChainDefinition,
    analyzeProblemDefinition,
    stepByStepAnalysisDefinition,
    formatAsPlanDefinition,
    generatePrdDefinition,
    createUserStoriesDefinition,
    analyzeRequirementsDefinition,
    featureRoadmapDefinition,
  
    // Prompt Engineering (3)
    enhancePromptDefinition,
    analyzePromptDefinition,
    enhancePromptGeminiDefinition,
  
    // Reasoning (1)
    applyReasoningFrameworkDefinition,
  
    // Analytics (1) - v2.0 NEW
    getUsageAnalyticsDefinition
  ];

• src/index.ts:155-212 (registration)

  Registration of formatAsPlan handler in toolHandlers object for dynamic dispatch in CallToolRequest.

  const toolHandlers: Record<string, ToolHandler> = {
    // Time & UI
    'get_current_time': getCurrentTime,
    'preview_ui_ascii': previewUiAscii,
  
    // Memory - Basic
    'save_memory': saveMemory,
    'recall_memory': recallMemory,
    'update_memory': updateMemory,
    'delete_memory': deleteMemory,
    'list_memories': listMemories,
    'prioritize_memory': prioritizeMemory,
  
    // Memory - Graph (v2.0 NEW)
    'link_memories': linkMemories,
    'get_memory_graph': getMemoryGraph,
    'search_memories_advanced': searchMemoriesAdvanced,
    'create_memory_timeline': createMemoryTimeline,
  
    // Memory - Session Context (v2.1 NEW)
    'get_session_context': getSessionContext,
  
    // Code Analysis
    'find_symbol': findSymbol,
    'find_references': findReferences,
    'analyze_dependency_graph': analyzeDependencyGraph,
  
    // Code Quality
    'get_coding_guide': getCodingGuide,
    'apply_quality_rules': applyQualityRules,
    'validate_code_quality': validateCodeQuality,
    'analyze_complexity': analyzeComplexity,
    'check_coupling_cohesion': checkCouplingCohesion,
    'suggest_improvements': suggestImprovements,
  
    // Thinking
    'create_thinking_chain': createThinkingChain,
    'analyze_problem': analyzeProblem,
    'step_by_step_analysis': stepByStepAnalysis,
    'format_as_plan': formatAsPlan,
  
    // Planning
    'generate_prd': generatePrd,
    'create_user_stories': createUserStories,
    'analyze_requirements': analyzeRequirements,
    'feature_roadmap': featureRoadmap,
  
    // Prompt
    'enhance_prompt': enhancePrompt,
    'analyze_prompt': analyzePrompt,
    'enhance_prompt_gemini': enhancePromptGemini,
  
    // Reasoning
    'apply_reasoning_framework': applyReasoningFramework,
  
    // Analytics (v2.0 NEW)
    'get_usage_analytics': getUsageAnalytics
  };

• src/index.ts:39-39 (registration)

  Import of formatAsPlanDefinition and formatAsPlan handler from the implementation file.

  import { formatAsPlanDefinition, formatAsPlan } from './tools/thinking/formatAsPlan.js';