CodeAnalysis MCP Server

Implementation Reference

• src/features/memory/index.ts:111-137 (handler)

  MCP tool handler for 'update-codebase-insight'. Calls the updateMemory helper to update the insight in the database and returns a success or error response.

    async ({ insightId, insightContent, insightType, relatedFiles, tags }) => {
      try {
        await updateMemory({
          id: insightId,
          insightContent,
          insightType,
          relatedFiles,
          tags
        });
        
        return {
          content: [{
            type: "text",
            text: `Successfully updated insight with ID: ${insightId}`
          }]
        };
      } catch (error) {
        return {
          content: [{
            type: "text",
            text: `Error updating insight: ${(error as Error).message}`
          }],
          isError: true
        };
      }
    }
  );

• src/features/memory/index.ts:104-110 (schema)

  Input schema for the 'update-codebase-insight' tool using Zod validation.

  {
    insightId: z.number(),
    insightContent: z.string().optional(),
    insightType: z.string().optional(),
    relatedFiles: z.array(z.string()).optional(),
    tags: z.array(z.string()).optional()
  },

• src/features/memory/index.ts:102-103 (registration)

  Registration of the 'update-codebase-insight' tool on the MCP server.

  server.tool(
    "update-codebase-insight",

• src/features/memory/memory-manager.ts:161-240 (helper)

  Helper function that performs the actual database update for an insight, including optional updates to content, type, related files, and tags using SQLite transactions.

  export async function updateMemory(updates: {
    id: number;
    insightContent?: string;
    insightType?: string;
    relatedFiles?: string[];
    tags?: string[];
  }): Promise<void> {
    if (!db) {
      db = await createDatabase("memory");
    }
    
    if (!db) {
      throw new Error("Database not initialized");
    }
    
    const { id, insightContent, insightType, relatedFiles, tags } = updates;
    
    // Begin transaction
    await db.exec('BEGIN TRANSACTION');
    
    try {
      // Update basic insight data if provided
      if (insightContent || insightType) {
        let sql = `UPDATE insights SET`;
        const params: any[] = [];
        
        if (insightContent) {
          sql += ` insightContent = ?,`;
          params.push(insightContent);
        }
        
        if (insightType) {
          sql += ` insightType = ?,`;
          params.push(insightType);
        }
        
        // Remove trailing comma
        sql = sql.slice(0, -1);
        
        sql += ` WHERE id = ?`;
        params.push(id);
        
        // Execute update
        await db.run(sql, params);
      }
      
      // Update related files if provided
      if (relatedFiles) {
        // Delete existing relationships
        await db.run(`DELETE FROM relatedFiles WHERE insightId = ?`, [id]);
        
        // Insert new relationships
        for (const filePath of relatedFiles) {
          await db.run(
            `INSERT INTO relatedFiles (insightId, filePath) VALUES (?, ?)`,
            [id, filePath]
          );
        }
      }
      
      // Update tags if provided
      if (tags) {
        // Delete existing tags
        await db.run(`DELETE FROM tags WHERE insightId = ?`, [id]);
        
        // Insert new tags
        for (const tag of tags) {
          await db.run(
            `INSERT INTO tags (insightId, tag) VALUES (?, ?)`,
            [id, tag]
          );
        }
      }
      
      await db.exec('COMMIT');
    } catch (error) {
      await db.exec('ROLLBACK');
      throw error;
    }
  }