capture

Instructions

Implementation Reference

• src/index.ts:123-200 (handler)

  The MCP 'capture' tool handler function. Initializes the CaptureEngine, processes input arguments into CaptureInput, executes capture, and returns formatted MCP CallToolResult with success summary or error.

  /**
   * Handle capture tool requests
   */
  async function handleCapture(args: any): Promise<CallToolResult> {
    try {
      await initializeCaptureEngine();
      
      if (!captureEngine) {
        throw new Error('Failed to initialize capture engine');
      }
  
      const input: CaptureInput = {
        text: args.text,
        inputType: 'text',
        forceContext: args.context,
      };
  
      const result: CaptureResult = await captureEngine.capture(input);
  
      if (!result.success) {
        return {
          content: [
            {
              type: 'text',
              text: `Capture failed: ${result.error}`,
            },
          ],
          isError: true,
        };
      }
  
      // Format successful capture result
      const summary = [
        `✅ Capture Successful!`,
        `📁 Primary Tracker: ${result.primaryTracker}`,
        `🎯 Confidence: ${Math.round(result.confidence * 100)}%`,
        `📊 Generated ${result.itemResults?.length || 0} items`,
        '',
      ];
  
      if (result.itemResults && result.itemResults.length > 0) {
        summary.push('📝 Items Generated:');
        result.itemResults.forEach(item => {
          summary.push(`  ✅ ${item.itemType} → ${item.tracker}`);
          summary.push(`     ${item.formattedEntry}`);
        });
      }
  
      if (result.completedTasks && result.completedTasks.length > 0) {
        summary.push('');
        summary.push('🎯 Task Completions:');
        result.completedTasks.forEach(completion => {
          summary.push(`  ✅ completion in ${completion.tracker}`);
          summary.push(`     ${completion.description}`);
        });
      }
  
      return {
        content: [
          {
            type: 'text',
            text: summary.join('\n'),
          },
        ],
        isError: false,
      };
    } catch (error) {
      return {
        content: [
          {
            type: 'text',
            text: `Error during capture: ${error instanceof Error ? error.message : String(error)}`,
          },
        ],
        isError: true,
      };
    }
  }

• src/index.ts:37-59 (schema)

  JSON schema definition for the 'capture' tool input, including required 'text' field and optional 'priority' and 'context'.

  {
    name: 'capture',
    description: 'Capture and route text input using ChurnFlow ADHD-friendly AI system',
    inputSchema: {
      type: 'object',
      properties: {
        text: {
          type: 'string',
          description: 'Text to capture and route (can contain multiple items)',
        },
        priority: {
          type: 'string',
          enum: ['high', 'medium', 'low'],
          description: 'Priority level for the captured content',
        },
        context: {
          type: 'string',
          description: 'Optional context hint for routing (business, personal, project, system)',
        },
      },
      required: ['text'],
    },
  },

• src/index.ts:334-350 (registration)

  Registration of CallToolRequestHandler with switch statement that dispatches calls to 'capture' tool to the handleCapture function.

  server.setRequestHandler(CallToolRequestSchema, async (request) => {
    const { name, arguments: args } = request.params;
  
    switch (name) {
      case 'capture':
        return await handleCapture(args);
      
      case 'status':
        return await handleStatus();
      
      case 'list_trackers':
        return await handleListTrackers(args);
      
      default:
        throw new Error(`Unknown tool: ${name}`);
    }
  });

• src/index.ts:329-331 (registration)

  Registration of ListToolsRequestHandler that returns the list of available tools including 'capture'.

  server.setRequestHandler(ListToolsRequestSchema, async () => {
    return { tools: TOOLS };
  });

• src/core/CaptureEngine.ts:69-183 (helper)

  Core implementation of capture logic in CaptureEngine class: AI inference, item/task processing, routing to trackers, database save, error handling with review/emergency fallbacks.

  async capture(input: string | CaptureInput): Promise<CaptureResult> {
    if (!this.initialized) {
      await this.initialize();
    }
  
    // Normalize input
    const captureInput: CaptureInput =
      typeof input === "string" ? { text: input, inputType: "text" } : input;
  
    console.log(`🎯 Capturing: "${captureInput.text}"`);
  
    try {
      // Use AI to infer routing and generate multiple items
      const inference = await this.inferenceEngine.inferCapture(captureInput);
  
      console.log(
        `🤖 AI inference: ${inference.primaryTracker} (${inference.confidence * 100}% confidence)`,
      );
      console.log(`📝 Analysis: ${inference.overallReasoning}`);
      console.log(
        `🔢 Generated ${inference.generatedItems.length} items, ${inference.taskCompletions.length} completions`,
      );
  
      // Handle low confidence - route to review
      if (inference.requiresReview) {
        return await this.routeToReview(captureInput, inference);
      }
  
      // Process task completions first
      const completedTasks = [];
      for (const completion of inference.taskCompletions) {
        console.log(`✅ Task completion detected: ${completion.description} in ${completion.tracker}`);
        
        // Actually mark the task as complete in the tracker file
        const success = await this.trackerManager.markTaskComplete(
          completion.tracker,
          completion.description
        );
        
        completedTasks.push({
          ...completion,
          success
        });
        
        if (success) {
          console.log(`✅ Successfully marked task as complete: ${completion.description}`);
        } else {
          console.error(`❌ Failed to mark task as complete: ${completion.description}`);
        }
      }
  
      // Process generated items
      const itemResults = [];
      for (const item of inference.generatedItems) {
        console.log(
          `📝 Processing ${item.itemType} for ${item.tracker}: ${item.reasoning}`,
        );
  
        let success: boolean;
        if (item.itemType === "activity") {
          success = await this.trackerManager.appendActivityToTracker(
            item.tracker,
            item.content,
          );
        } else {
          success = await this.trackerManager.appendToTracker(
            item.tracker,
            item.content,
          );
        }
  
        itemResults.push({
          success,
          tracker: item.tracker,
          itemType: item.itemType,
          formattedEntry: item.content,
          error: success ? undefined : `Failed to write to ${item.tracker}`,
        });
  
        if (success) {
          console.log(
            `✅ ${item.itemType} successfully added to ${item.tracker}`,
          );
        } else {
          console.error(`❌ Failed to add ${item.itemType} to ${item.tracker}`);
        }
      }
  
      // Determine overall success
      const overallSuccess = itemResults.some((result) => result.success);
      
      // Save to database if available (optional - doesn't affect capture success)
      if (overallSuccess && this.databaseAvailable) {
        try {
          await this.saveCaptureToDatabase(captureInput, inference, itemResults, overallSuccess);
        } catch (dbError) {
          console.warn("⚠️ Failed to save to database (file saved successfully):", dbError);
        }
      }
  
      return {
        success: overallSuccess,
        primaryTracker: inference.primaryTracker,
        confidence: inference.confidence,
        itemResults,
        completedTasks,
        requiresReview: false,
      };
    } catch (error) {
      console.error("❌ Capture failed:", error);
  
      // Emergency fallback - try to save somewhere
      return await this.emergencyCapture(captureInput, error as Error);
    }
  }