get_solution_details

Instructions

Implementation Reference

• src/tools/solutionTools.ts:280-293 (handler)

  The tool handler definition with name 'get_solution_details', input schema (solution_name), and execute function that delegates to SingleSolutionLoader.analyzeSolution().

  export const getSolutionDetailsTool = {
    name: 'get_solution_details',
    description: 'Get detailed information about a specific solution (fast - only analyzes requested solution)',
    inputSchema: z.object({
      solution_name: z.string().describe('The solution name'),
    }),
    execute: async (args: { solution_name: string }): Promise<SolutionDetails | null> => {
      // Use optimized single-solution analyzer - no need to analyze all 480!
      const github = repoManager.getGitHubClient();
      const analyzer = new SingleSolutionLoader(github);
  
      return await analyzer.analyzeSolution(args.solution_name);
    },
  };

• src/loaders/singleSolutionLoader.ts:28-96 (handler)

  The core handler logic that loads solution metadata, fetches connector files, resolves parsers, and returns detailed solution info including connectors and unique tables.

  async analyzeSolution(solutionName: string): Promise<SolutionDetails | null> {
    console.error(`Analyzing solution: ${solutionName}`);
  
    const solutionPath = `Solutions/${solutionName}`;
  
    // 1. Load metadata
    const metadata = await this.loadSolutionMetadata(solutionPath, solutionName);
    if (!metadata) {
      return null;
    }
  
    // 2. Get tree to find connector and parser files
    console.error('Fetching solution files from GitHub...');
    const tree = await this.github.getTree();
  
    // 3. Find connector files for this solution only
    const connectorFiles = tree.tree.filter(
      (item) =>
        item.path.startsWith(`${solutionPath}/Data Connectors`) &&
        (item.path.endsWith('.json') || item.path.endsWith('.JSON')) &&
        item.type === 'blob'
    );
  
    console.error(`Found ${connectorFiles.length} connectors`);
  
    if (connectorFiles.length === 0) {
      return {
        metadata,
        connectors: [],
        uniqueTables: [],
        githubUrl: this.github.getGitHubUrl(solutionPath),
      };
    }
  
    // 4. Load parsers for this solution
    const parserResolver = new ParserResolver(solutionPath, tree.tree, this.github);
    await parserResolver.loadParsers();
  
    // 5. Analyze connectors
    const connectors: Array<{
      id: string;
      title: string;
      description?: string;
      tables: string[];
    }> = [];
  
    const allTables = new Set<string>();
  
    for (const connectorFile of connectorFiles) {
      const connectorData = await this.analyzeConnector(
        connectorFile.path,
        parserResolver
      );
  
      if (connectorData) {
        connectors.push(connectorData);
        connectorData.tables.forEach((table) => allTables.add(table));
      }
    }
  
    console.error(`Analysis complete! Found ${allTables.size} unique tables`);
  
    return {
      metadata,
      connectors,
      uniqueTables: Array.from(allTables),
      githubUrl: this.github.getGitHubUrl(solutionPath),
    };
  }

• src/types/index.ts:125-135 (schema)

  The SolutionDetails type definition - the return type of get_solution_details tool.

  export interface SolutionDetails {
    metadata: SolutionMetadata;
    connectors: Array<{
      id: string;
      title: string;
      description?: string;
      tables: string[];
    }>;
    uniqueTables: string[];
    githubUrl?: string;
  }

• src/tools/solutionTools.ts:283-285 (schema)

  The input schema for the tool, requiring a 'solution_name' string parameter.

  inputSchema: z.object({
    solution_name: z.string().describe('The solution name'),
  }),

• src/tools/index.ts:60-60 (registration)

  Tool re-exported in the consolidated index.ts, making it available as part of the allTools collection.

  getSolutionDetailsTool,