getCardContent

Implementation Reference

• src/tools/getCardContent.ts:10-68 (handler)

  The core implementation of the getCardContent tool handler. Fetches card data, processes content based on format (raw, markdown, json), and returns as MCP resource.

  export async function getCardContentHandler(
    params: z.infer<typeof getCardContentSchema>,
    dataService: HeptabaseDataService
  ) {
    const result = await dataService.getCard(params.cardId);
    const card = result.card;
    
    if (!card) {
      throw new Error('Card not found');
    }
    
    let content: string;
    let mimeType: string = 'text/plain';
    
    switch (params.format) {
      case 'raw':
        content = card.content;
        mimeType = 'text/plain';
        break;
        
      case 'json':
        const cardData = {
          id: card.id,
          title: card.title,
          content: JSON.parse(card.content),
          createdTime: card.createdTime,
          lastEditedTime: card.lastEditedTime,
          instances: result.instances.length
        };
        content = JSON.stringify(cardData, null, 2);
        mimeType = 'application/json';
        break;
        
      case 'markdown':
      default:
        content = `# ${card.title || 'Untitled'}\n\n`;
        content += parseHeptabaseContentToMarkdown(card.content);
        content += `\n\n---\n`;
        content += `Created: ${card.createdTime}\n`;
        content += `Last edited: ${card.lastEditedTime}\n`;
        content += `Card ID: ${card.id}\n`;
        if (result.instances.length > 0) {
          content += `\nAppears on ${result.instances.length} whiteboard(s)\n`;
        }
        mimeType = 'text/markdown';
        break;
    }
    
    return {
      content: [{
        type: 'resource',
        resource: {
          uri: `heptabase://card/${card.id}`,
          mimeType,
          text: content
        }
      }]
    };
  }

• src/tools/getCardContent.ts:5-8 (schema)

  Zod input schema for the getCardContent tool, defining cardId and optional format parameters.

  export const getCardContentSchema = z.object({
    cardId: z.string(),
    format: z.enum(['raw', 'markdown', 'json']).default('markdown')
  });

• src/server.ts:587-616 (registration)

  Registration of the getCardContent tool on the MCP server. Defines schema, creates a wrapper handler that dynamically imports and calls the core implementation, and registers with this.server.tool.

  // getCardContent - returns full card content as resource to bypass text limits
  const getCardContentSchema = z.object({
    cardId: z.string(),
    format: z.enum(['raw', 'markdown', 'json']).default('markdown')
  });
  
  this.tools.getCardContent = {
    inputSchema: getCardContentSchema,
    handler: async (params) => {
      try {
        await this.ensureDataServiceInitialized();
        
        const handler = await import('./tools/getCardContent');
        return handler.getCardContentHandler(params, this.dataService!);
      } catch (error) {
        console.error('Error in getCardContent:', error);
        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
        return {
          content: [{
            type: 'text',
            text: `Error: ${errorMessage}`
          }]
        };
      }
    }
  };
  
  this.server.tool('getCardContent', getCardContentSchema.shape, async (params) => {
    return this.tools.getCardContent.handler(params);
  });