CodeAnalysis MCP Server

Implementation Reference

• src/features/memory/index.ts:64-99 (handler)

  Registration and handler implementation for the 'retrieve-codebase-insights' MCP tool. Includes Zod input schema validation and logic to call the retrieveMemories helper, format results as JSON, and handle errors.

  server.tool(
    "retrieve-codebase-insights",
    {
      repositoryUrl: z.string(),
      insightTypes: z.array(z.string()).optional(),
      tags: z.array(z.string()).optional(),
      relatedFile: z.string().optional(),
      limit: z.number().optional()
    },
    async ({ repositoryUrl, insightTypes, tags, relatedFile, limit }) => {
      try {
        const memories = await retrieveMemories({
          repositoryUrl,
          insightTypes,
          tags,
          relatedFile,
          limit: limit || 10
        });
        
        return {
          content: [{
            type: "text",
            text: JSON.stringify(memories, null, 2)
          }]
        };
      } catch (error) {
        return {
          content: [{
            type: "text",
            text: `Error retrieving insights: ${(error as Error).message}`
          }],
          isError: true
        };
      }
    }
  );

• src/features/memory/memory-manager.ts:74-156 (helper)

  Supporting helper function that implements the database query logic for retrieving codebase insights based on repository, types, tags, related files, and limit. Fetches base insights then populates related files and tags for each.

  export async function retrieveMemories(query: MemoryQuery): Promise<Insight[]> {
    if (!db) {
      db = await createDatabase("memory");
    }
  
    if (!db) {
      throw new Error("Database not initialized");
    }
  
    const { repositoryUrl, insightTypes, tags, relatedFile, limit } = query;
    
    // Base query
    let sql = `
      SELECT 
        i.id, 
        i.repositoryUrl, 
        i.insightType, 
        i.category, 
        i.insightContent, 
        i.timestamp
      FROM insights i
    `;
    
    const params: any[] = [repositoryUrl];
    
    // Add conditions for related files
    if (relatedFile) {
      sql += `
        JOIN relatedFiles rf ON i.id = rf.insightId
        WHERE i.repositoryUrl = ? AND rf.filePath = ?
      `;
      params.push(relatedFile);
    } else {
      sql += ` WHERE i.repositoryUrl = ?`;
    }
    
    // Add conditions for insight types
    if (insightTypes && insightTypes.length > 0) {
      sql += ` AND i.insightType IN (${insightTypes.map(() => '?').join(',')})`;
      params.push(...insightTypes);
    }
    
    // Add conditions for tags
    if (tags && tags.length > 0) {
      sql += `
        AND i.id IN (
          SELECT insightId FROM tags
          WHERE tag IN (${tags.map(() => '?').join(',')})
          GROUP BY insightId
          HAVING COUNT(DISTINCT tag) = ?
        )
      `;
      params.push(...tags, tags.length); // Ensure all tags match
    }
    
    // Add order and limit
    sql += ` ORDER BY i.timestamp DESC`;
    
    if (limit) {
      sql += ` LIMIT ?`;
      params.push(limit);
    }
    
    // Execute query
    const insights = await db.all(sql, params);
    
    // For each insight, fetch related files and tags
    for (const insight of insights) {
      // Get related files
      insight.relatedFiles = await db.all(
        `SELECT filePath FROM relatedFiles WHERE insightId = ?`,
        [insight.id]
      ).then(rows => rows.map((row: any) => row.filePath));
      
      // Get tags
      insight.tags = await db.all(
        `SELECT tag FROM tags WHERE insightId = ?`,
        [insight.id]
      ).then(rows => rows.map((row: any) => row.tag));
    }
    
    return insights;
  }