CodeAnalysis MCP Server

Implementation Reference

• src/features/multi-repo/index.ts:10-43 (registration)

  Registers the 'cross-repo-analysis' MCP tool with input schema and handler function.

  server.tool(
    "cross-repo-analysis",
    {
      primaryRepoUrl: z.string(),
      relatedRepoUrls: z.array(z.string()),
      analysisType: z.enum(["dependencies", "api-usage", "architectural-patterns"]).default("dependencies"),
      contextDepth: z.number().min(1).max(3).default(2)
    },
    async ({ primaryRepoUrl, relatedRepoUrls, analysisType, contextDepth }) => {
      try {
        const results = await analyzeMultipleRepositories(
          primaryRepoUrl, 
          relatedRepoUrls, 
          analysisType,
          contextDepth
        );
        
        return {
          content: [{
            type: "text",
            text: JSON.stringify(results, null, 2)
          }]
        };
      } catch (error) {
        return {
          content: [{
            type: "text",
            text: `Error in cross-repository analysis: ${(error as Error).message}`
          }],
          isError: true
        };
      }
    }
  );

• src/features/multi-repo/index.ts:12-17 (schema)

  Input schema using Zod for primaryRepoUrl (string), relatedRepoUrls (array of strings), analysisType (enum with default), contextDepth (number 1-3 default 2).

  {
    primaryRepoUrl: z.string(),
    relatedRepoUrls: z.array(z.string()),
    analysisType: z.enum(["dependencies", "api-usage", "architectural-patterns"]).default("dependencies"),
    contextDepth: z.number().min(1).max(3).default(2)
  },

• src/features/multi-repo/index.ts:18-42 (handler)

  Tool execution handler: invokes analyzeMultipleRepositories with parameters and returns formatted JSON results or error response.

  async ({ primaryRepoUrl, relatedRepoUrls, analysisType, contextDepth }) => {
    try {
      const results = await analyzeMultipleRepositories(
        primaryRepoUrl, 
        relatedRepoUrls, 
        analysisType,
        contextDepth
      );
      
      return {
        content: [{
          type: "text",
          text: JSON.stringify(results, null, 2)
        }]
      };
    } catch (error) {
      return {
        content: [{
          type: "text",
          text: `Error in cross-repository analysis: ${(error as Error).message}`
        }],
        isError: true
      };
    }
  }

• src/features/multi-repo/multi-repo-analyzer.ts:11-77 (helper)

  Main analysis function: clones repositories, builds knowledge graphs, dispatches to type-specific analysis, and compiles summaries and relationships.

  export async function analyzeMultipleRepositories(
    primaryRepoUrl: string,
    relatedRepoUrls: string[],
    analysisType: "dependencies" | "api-usage" | "architectural-patterns",
    contextDepth: number = 2
  ): Promise<any> {
    // Step 1: Clone/update all repositories
    const primaryRepoPath = await getRepository(primaryRepoUrl);
    const relatedRepoPaths = await Promise.all(
      relatedRepoUrls.map(url => getRepository(url))
    );
    
    // Step 2: Build knowledge graphs for each repository
    console.log(`Building knowledge graph for primary repository: ${primaryRepoUrl}`);
    const primaryGraph = await buildKnowledgeGraph(primaryRepoUrl, contextDepth, false);
    
    console.log(`Building knowledge graphs for ${relatedRepoUrls.length} related repositories`);
    const relatedGraphsPromises = relatedRepoUrls.map(async (url, index) => {
      console.log(`Building graph for related repository ${index + 1}: ${url}`);
      return {
        url,
        graph: await buildKnowledgeGraph(url, contextDepth, false)
      };
    });
    
    const relatedGraphs = await Promise.all(relatedGraphsPromises);
    
    // Step 3: Analyze cross-repository relationships based on analysis type
    let crossRepoRelationships;
    
    switch (analysisType) {
      case "dependencies":
        crossRepoRelationships = await analyzeCrossDependencies(
          primaryRepoUrl,
          relatedRepoUrls
        );
        break;
      case "api-usage":
        crossRepoRelationships = await analyzeApiUsage(
          primaryRepoUrl,
          relatedRepoUrls
        );
        break;
      case "architectural-patterns":
        crossRepoRelationships = await analyzeArchitecturalPatterns(
          primaryRepoUrl,
          relatedRepoUrls
        );
        break;
      default:
        throw new Error(`Unknown analysis type: ${analysisType}`);
    }
    
    // Step 4: Prepare the result
    return {
      primaryRepository: {
        url: primaryRepoUrl,
        summary: await summarizeRepository(primaryRepoUrl)
      },
      relatedRepositories: await Promise.all(relatedRepoUrls.map(async (url) => ({
        url,
        summary: await summarizeRepository(url)
      }))),
      relationships: crossRepoRelationships,
      analysisType
    };
  }

• src/features/multi-repo/multi-repo-analyzer.ts:82-132 (helper)

  Analyzes shared dependencies between primary and related repositories using knowledge graph queries.

  async function analyzeCrossDependencies(
    primaryRepoUrl: string,
    relatedRepoUrls: string[]
  ): Promise<any> {
    const results: any[] = [];
    
    // Step 1: Get dependency nodes from primary repo
    const primaryResult = await queryKnowledgeGraph({
      query: "dependencies",
      repositoryUrl: primaryRepoUrl,
      contextDepth: 2
    });
    
    const primaryDependencies = primaryResult.nodes.filter(
      node => node.type === "dependency"
    );
    
    // Step 2: For each related repo, find matching dependencies
    for (const relatedUrl of relatedRepoUrls) {
      const relatedResult = await queryKnowledgeGraph({
        query: "dependencies", 
        repositoryUrl: relatedUrl,
        contextDepth: 2
      });
      
      const relatedDependencies = relatedResult.nodes.filter(
        node => node.type === "dependency"
      );
      
      // Find shared dependencies
      const sharedDependencies = primaryDependencies.filter(primaryDep => 
        relatedDependencies.some(relatedDep => 
          primaryDep.name === relatedDep.name
        )
      );
      
      if (sharedDependencies.length > 0) {
        results.push({
          primaryRepository: primaryRepoUrl,
          relatedRepository: relatedUrl,
          type: "shared-dependencies",
          items: sharedDependencies.map(dep => ({
            name: dep.name,
            details: dep.attributes
          }))
        });
      }
    }
    
    return results;
  }