consult-llm-mcp 1.0.0

package/README.md

@@ -0,0 +1,146 @@
+# Consult LLM MCP
+
+An MCP (Model Context Protocol) server that allows you to consult more powerful
+AI models with your code and questions.
+
+## Features
+
+- Query powerful AI models (o3, Gemini 2.5 Pro, DeepSeek Reasoner) with file
+  context
+- Automatic prompt construction from markdown and code files
+- Git diff to feed code changes
+- Usage tracking with cost estimation
+- Comprehensive logging
+
+## Installation
+
+```bash
+npm install
+npm run build
+npm install -g .
+```
+
+## Configuration
+
+Set the following environment variables:
+
+- `OPENAI_API_KEY` - Your OpenAI API key (required for o3)
+- `GEMINI_API_KEY` - Your Google AI API key (required for Gemini models)
+- `DEEPSEEK_API_KEY` - Your DeepSeek API key (required for DeepSeek models)
+- `CONSULT_LLM_DEFAULT_MODEL` - Override the default model (optional, defaults
+  to 'o3')
+
+## Usage with Claude Code
+
+Add the MCP server to Claude Code:
+
+```bash
+claude mcp add consult-llm -- consult-llm-mcp
+```
+
+Or for global availability:
+
+```bash
+claude mcp add --scope user consult-llm -- consult-llm-mcp
+```
+
+## MCP Tool: consult_llm
+
+The server provides a single tool called `consult_llm` for asking powerful AI
+models complex questions.
+
+### Parameters
+
+- **files** (required): Array of file paths to process
+
+  - Markdown files (.md) become the main prompt
+  - Other files are added as context with file paths and code blocks
+
+- **model** (optional): LLM model to use
+
+  - Options: `o3` (default), `gemini-2.5-pro`, `deepseek-reasoner`
+
+- **git_diff** (optional): Include git diff output as context
+  - **files** (required): Specific files to include in diff
+  - **repo_path** (optional): Path to git repository (defaults to current
+    directory)
+  - **base_ref** (optional): Git reference to compare against (defaults to HEAD)
+
+### Example Usage
+
+```json
+{
+  "files": ["src/auth.ts", "src/middleware.ts", "review.md"],
+  "model": "o3",
+  "git_diff": {
+    "files": ["src/auth.ts", "src/middleware.ts"],
+    "base_ref": "main"
+  }
+}
+```
+
+## Supported Models
+
+- **o3**: OpenAI's reasoning model ($2/$8 per million tokens)
+- **gemini-2.5-pro**: Google's Gemini 2.5 Pro ($1.25/$10 per million tokens)
+- **deepseek-reasoner**: DeepSeek's reasoning model ($0.55/$2.19 per million
+  tokens)
+
+## Logging
+
+All prompts and responses are logged to `~/.consult-llm-mcp/logs/mcp.log` with:
+
+- Tool call parameters
+- Full prompts and responses
+- Token usage and cost estimates
+
+## CLAUDE.md example
+
+To help Claude Code understand when and how to use this tool, you can add the
+following to your project's `CLAUDE.md` file:
+
+````markdown
+## consult-llm-mcp
+
+Use the `consult_llm` MCP tool to ask a more powerful AI for help with complex
+problems. Write your problem description in a markdown file with as much detail
+as possible and pass relevant code files as context. Include files to git_diff
+when asking feedback for changes.
+
+Use Gemini 2.5 Pro.
+
+### Example
+
+```bash
+echo "<very detailed plan or question to be reviewed by the smart LLM>" > task.md
+```
+
+Tool call:
+
+```json
+{
+  "files": [
+    "server/src/db.ts",
+    "server/src/routes/conversations.ts",
+    "task.md"
+  ],
+  "git_diff": {
+    "files": ["server/src/db.ts", "server/src/routes/conversations.ts"]
+  },
+  "model": "gemini-2.5-pro"
+}
+```
+````
+
+## Development
+
+```bash
+# Run in development mode
+npm run dev
+
+# Build TypeScript
+npm run build
+
+# Format code
+npm run format
+```

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import { getClientForModel } from './index.js';
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.length === 0) {
+        console.error('Usage: llmtool <prompt>');
+        console.error('Environment variables:');
+        console.error('  OPENAI_API_KEY - Required for GPT models');
+        console.error('  GEMINI_API_KEY - Required for Gemini models');
+        console.error('  MODEL - Model to use (default: gpt-3.5-turbo)');
+        process.exit(1);
+    }
+    const prompt = args.join(' ');
+    const model = process.env.MODEL || 'gpt-3.5-turbo';
+    try {
+        const { client } = getClientForModel(model);
+        const completion = await client.chat.completions.create({
+            model,
+            messages: [{ role: 'user', content: prompt }],
+            temperature: 0.7,
+        });
+        const response = completion.choices[0]?.message?.content;
+        if (response) {
+            console.log(response);
+        }
+        else {
+            console.error('No response from the model');
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/dist/config.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod/v4';
+declare const Config: z.ZodObject<{
+    openaiApiKey: z.ZodOptional<z.ZodString>;
+    geminiApiKey: z.ZodOptional<z.ZodString>;
+    deepseekApiKey: z.ZodOptional<z.ZodString>;
+    defaultModel: z.ZodOptional<z.ZodEnum<{
+        o3: "o3";
+        "gemini-2.5-pro": "gemini-2.5-pro";
+        "deepseek-reasoner": "deepseek-reasoner";
+    }>>;
+}, z.core.$strip>;
+export type Config = z.infer<typeof Config>;
+export declare const config: {
+    openaiApiKey?: string | undefined;
+    geminiApiKey?: string | undefined;
+    deepseekApiKey?: string | undefined;
+    defaultModel?: "o3" | "gemini-2.5-pro" | "deepseek-reasoner" | undefined;
+};
+export {};

package/dist/config.js

@@ -0,0 +1,22 @@
+import { z } from 'zod/v4';
+import { SupportedChatModel } from './schema.js';
+const Config = z.object({
+    openaiApiKey: z.string().optional(),
+    geminiApiKey: z.string().optional(),
+    deepseekApiKey: z.string().optional(),
+    defaultModel: SupportedChatModel.optional(),
+});
+const parsedConfig = Config.safeParse({
+    openaiApiKey: process.env.OPENAI_API_KEY,
+    geminiApiKey: process.env.GEMINI_API_KEY,
+    deepseekApiKey: process.env.DEEPSEEK_API_KEY,
+    defaultModel: process.env.CONSULT_LLM_DEFAULT_MODEL,
+});
+if (!parsedConfig.success) {
+    console.error('❌ Invalid environment variables:');
+    for (const issue of parsedConfig.error.issues) {
+        console.error(`  ${issue.path.join('.')}: ${issue.message}`);
+    }
+    process.exit(1);
+}
+export const config = parsedConfig.data;

package/dist/file.d.ts

@@ -0,0 +1,7 @@
+export declare function processFiles(files: string[]): {
+    markdownFiles: string[];
+    otherFiles: {
+        path: string;
+        content: string;
+    }[];
+};

package/dist/file.js

@@ -0,0 +1,23 @@
+import { readFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+export function processFiles(files) {
+    const resolvedFiles = files.map((f) => resolve(f));
+    const missingFiles = resolvedFiles.filter((f) => !existsSync(f));
+    if (missingFiles.length > 0) {
+        throw new Error(`Files not found: ${missingFiles.join(', ')}`);
+    }
+    const markdownFiles = [];
+    const otherFiles = [];
+    for (let i = 0; i < files.length; i++) {
+        const filePath = resolvedFiles[i];
+        const originalPath = files[i];
+        const content = readFileSync(filePath, 'utf-8');
+        if (originalPath.endsWith('.md') || originalPath.endsWith('.markdown')) {
+            markdownFiles.push(content);
+        }
+        else {
+            otherFiles.push({ path: originalPath, content });
+        }
+    }
+    return { markdownFiles, otherFiles };
+}

package/dist/git.d.ts

@@ -0,0 +1 @@
+export declare function generateGitDiff(repoPath: string | undefined, files: string[], baseRef?: string): string;

package/dist/git.js

@@ -0,0 +1,17 @@
+import { execSync } from 'child_process';
+export function generateGitDiff(repoPath, files, baseRef = 'HEAD') {
+    try {
+        const repo = repoPath || process.cwd();
+        if (files.length === 0) {
+            throw new Error('No files specified for git diff');
+        }
+        return execSync(`git diff ${baseRef} -- ${files.join(' ')}`, {
+            cwd: repo,
+            encoding: 'utf-8',
+            maxBuffer: 1024 * 1024,
+        });
+    }
+    catch (error) {
+        return `Error generating git diff: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import OpenAI from 'openai';
+export declare function getClientForModel(model: string): {
+    client: OpenAI;
+};

package/dist/index.js

@@ -0,0 +1,25 @@
+import OpenAI from 'openai';
+import { config } from './config.js';
+const clients = {};
+export function getClientForModel(model) {
+    if (model.startsWith('gpt-')) {
+        if (!clients.openai) {
+            clients.openai = new OpenAI({
+                apiKey: config.openaiApiKey,
+            });
+        }
+        return { client: clients.openai };
+    }
+    else if (model.startsWith('gemini-')) {
+        if (!clients.gemini) {
+            clients.gemini = new OpenAI({
+                apiKey: config.geminiApiKey,
+                baseURL: 'https://generativelanguage.googleapis.com/v1beta/openai/',
+            });
+        }
+        return { client: clients.gemini };
+    }
+    else {
+        throw new Error(`Unable to determine LLM provider for model: ${model}`);
+    }
+}

package/dist/llm-cost.d.ts

@@ -0,0 +1,7 @@
+import { CompletionUsage } from 'openai/resources.js';
+import { type SupportedChatModel } from './schema.js';
+export declare function calculateCost(usage: CompletionUsage | undefined, model: SupportedChatModel): {
+    inputCost: number;
+    outputCost: number;
+    totalCost: number;
+};

package/dist/llm-cost.js

@@ -0,0 +1,26 @@
+const MODEL_PRICING = {
+    o3: {
+        inputCostPerMillion: 2.0,
+        outputCostPerMillion: 8.0,
+    },
+    'gemini-2.5-pro': {
+        inputCostPerMillion: 1.25,
+        outputCostPerMillion: 10.0,
+    },
+    'deepseek-reasoner': {
+        inputCostPerMillion: 0.55,
+        outputCostPerMillion: 2.19,
+    },
+};
+export function calculateCost(usage, model) {
+    const pricing = MODEL_PRICING[model];
+    if (!pricing) {
+        return { inputCost: 0, outputCost: 0, totalCost: 0 };
+    }
+    const inputTokens = usage?.prompt_tokens || 0;
+    const outputTokens = usage?.completion_tokens || 0;
+    const inputCost = (inputTokens / 1_000_000) * pricing.inputCostPerMillion;
+    const outputCost = (outputTokens / 1_000_000) * pricing.outputCostPerMillion;
+    const totalCost = inputCost + outputCost;
+    return { inputCost, outputCost, totalCost };
+}

package/dist/llm-query.d.ts

@@ -0,0 +1,5 @@
+import { type SupportedChatModel } from './schema.js';
+export declare function queryLlm(prompt: string, model: SupportedChatModel): Promise<{
+    response: string;
+    costInfo: string;
+}>;

package/dist/llm-query.js

@@ -0,0 +1,20 @@
+import { getClientForModel } from './llm.js';
+import { calculateCost } from './llm-cost.js';
+export async function queryLlm(prompt, model) {
+    const { client } = getClientForModel(model);
+    const completion = await client.chat.completions.create({
+        model,
+        messages: [{ role: 'user', content: prompt }],
+    });
+    const response = completion.choices[0]?.message?.content;
+    if (!response) {
+        throw new Error('No response from the model');
+    }
+    const usage = completion.usage;
+    // Calculate costs
+    const { inputCost, outputCost, totalCost } = calculateCost(usage, model);
+    const costInfo = usage
+        ? `Tokens: ${usage.prompt_tokens} input, ${usage.completion_tokens} output | Cost: $${totalCost.toFixed(6)} (input: $${inputCost.toFixed(6)}, output: $${outputCost.toFixed(6)})`
+        : 'Usage data not available';
+    return { response, costInfo };
+}

package/dist/llm.d.ts

@@ -0,0 +1,5 @@
+import OpenAI from 'openai';
+import { type SupportedChatModel as SupportedChatModelType } from './schema.js';
+export declare function getClientForModel(model: SupportedChatModelType | string): {
+    client: OpenAI;
+};

package/dist/llm.js

@@ -0,0 +1,34 @@
+import OpenAI from 'openai';
+import { config } from './config.js';
+const clients = {};
+export function getClientForModel(model) {
+    if (model.startsWith('gpt-') || model === 'o3') {
+        if (!clients.openai) {
+            clients.openai = new OpenAI({
+                apiKey: config.openaiApiKey,
+            });
+        }
+        return { client: clients.openai };
+    }
+    else if (model.startsWith('gemini-')) {
+        if (!clients.gemini) {
+            clients.gemini = new OpenAI({
+                apiKey: config.geminiApiKey,
+                baseURL: 'https://generativelanguage.googleapis.com/v1beta/openai/',
+            });
+        }
+        return { client: clients.gemini };
+    }
+    else if (model.startsWith('deepseek-')) {
+        if (!clients.deepseek) {
+            clients.deepseek = new OpenAI({
+                apiKey: config.deepseekApiKey,
+                baseURL: 'https://api.deepseek.com',
+            });
+        }
+        return { client: clients.deepseek };
+    }
+    else {
+        throw new Error(`Unable to determine LLM provider for model: ${model}`);
+    }
+}

package/dist/logger.d.ts

@@ -0,0 +1,4 @@
+export declare function logToFile(content: string): void;
+export declare function logToolCall(name: string, args: unknown): void;
+export declare function logPrompt(model: string, prompt: string): void;
+export declare function logResponse(model: string, response: string, costInfo: string): void;

package/dist/logger.js

@@ -0,0 +1,30 @@
+import { appendFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+const logDir = join(homedir(), '.consult-llm-mcp', 'logs');
+const logFile = join(logDir, 'mcp.log');
+try {
+    mkdirSync(logDir, { recursive: true });
+}
+catch (error) {
+    // Directory might already exist
+}
+export function logToFile(content) {
+    const timestamp = new Date().toISOString();
+    const logEntry = `[${timestamp}] ${content}\n`;
+    try {
+        appendFileSync(logFile, logEntry);
+    }
+    catch (error) {
+        console.error('Failed to write to log file:', error);
+    }
+}
+export function logToolCall(name, args) {
+    logToFile(`TOOL CALL: ${name}\nArguments: ${JSON.stringify(args, null, 2)}\n${'='.repeat(80)}`);
+}
+export function logPrompt(model, prompt) {
+    logToFile(`PROMPT (model: ${model}):\n${prompt}\n${'='.repeat(80)}`);
+}
+export function logResponse(model, response, costInfo) {
+    logToFile(`RESPONSE (model: ${model}):\n${response}\n${costInfo}\n${'='.repeat(80)}`);
+}

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/main.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { config } from './config.js';
+import { ConsultLlmArgs, toolSchema } from './schema.js';
+import { processFiles } from './file.js';
+import { generateGitDiff } from './git.js';
+import { buildPrompt } from './prompt-builder.js';
+import { queryLlm } from './llm-query.js';
+import { logToolCall, logPrompt, logResponse } from './logger.js';
+const server = new Server({
+    name: 'consult_llm',
+    version: '1.0.0',
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [toolSchema],
+    };
+});
+async function handleConsultLlm(args) {
+    const parseResult = ConsultLlmArgs.safeParse(args);
+    if (!parseResult.success) {
+        const errors = parseResult.error.issues
+            .map((issue) => `${issue.path.join('.')}: ${issue.message}`)
+            .join(', ');
+        throw new Error(`Invalid request parameters: ${errors}`);
+    }
+    const { files, git_diff } = parseResult.data;
+    const model = parseResult.data.model ?? config.defaultModel ?? 'o3';
+    logToolCall('consult_llm', args);
+    // Process files
+    const { markdownFiles, otherFiles } = processFiles(files);
+    // Generate git diff
+    const gitDiffOutput = git_diff
+        ? generateGitDiff(git_diff.repo_path, git_diff.files, git_diff.base_ref)
+        : undefined;
+    // Build prompt
+    const prompt = buildPrompt(markdownFiles, otherFiles, gitDiffOutput);
+    logPrompt(model, prompt);
+    // Query LLM
+    const { response, costInfo } = await queryLlm(prompt, model);
+    logResponse(model, response, costInfo);
+    return {
+        content: [{ type: 'text', text: response }],
+    };
+}
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    if (request.params.name === 'consult_llm') {
+        try {
+            return await handleConsultLlm(request.params.arguments);
+        }
+        catch (error) {
+            throw new Error(`LLM query failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    throw new Error(`Unknown tool: ${request.params.name}`);
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/dist/mcp-server.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/mcp-server.js

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { getClientForModel } from './llm.js';
+import { readFileSync, existsSync, appendFileSync, mkdirSync } from 'fs';
+import { resolve, join } from 'path';
+import { homedir } from 'os';
+import { execSync } from 'child_process';
+const MODEL_PRICING = {
+    o3: {
+        inputCostPerMillion: 2.0,
+        outputCostPerMillion: 8.0,
+    },
+    'gemini-2.5-pro': {
+        inputCostPerMillion: 1.25,
+        outputCostPerMillion: 10.0,
+    },
+};
+function calculateCost(usage, model) {
+    const pricing = MODEL_PRICING[model];
+    if (!pricing) {
+        return { inputCost: 0, outputCost: 0, totalCost: 0 };
+    }
+    const inputTokens = usage?.prompt_tokens || 0;
+    const outputTokens = usage?.completion_tokens || 0;
+    const inputCost = (inputTokens / 1_000_000) * pricing.inputCostPerMillion;
+    const outputCost = (outputTokens / 1_000_000) * pricing.outputCostPerMillion;
+    const totalCost = inputCost + outputCost;
+    return { inputCost, outputCost, totalCost };
+}
+// Setup logging directory
+const logDir = join(homedir(), '.llmtool', 'logs');
+const logFile = join(logDir, 'mcp.log');
+try {
+    mkdirSync(logDir, { recursive: true });
+}
+catch (error) {
+    // Directory might already exist
+}
+function logToFile(content) {
+    const timestamp = new Date().toISOString();
+    const logEntry = `[${timestamp}] ${content}\n`;
+    try {
+        appendFileSync(logFile, logEntry);
+    }
+    catch (error) {
+        console.error('Failed to write to log file:', error);
+    }
+}
+const server = new Server({
+    name: 'llmtool',
+    version: '1.0.0',
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: 'llm_query',
+                description: 'Ask a more powerful AI for help with complex problems. Write your problem description in a markdown file and pass relevant code files as context.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        files: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Array of file paths to process. Markdown files (.md) become the main prompt, other files are added as context with file paths and code blocks.',
+                        },
+                        model: {
+                            type: 'string',
+                            enum: ['o3', 'gemini-2.5-pro'],
+                            default: 'o3',
+                            description: 'LLM model to use',
+                        },
+                        git_diff: {
+                            type: 'object',
+                            properties: {
+                                repo_path: {
+                                    type: 'string',
+                                    description: 'Path to git repository (defaults to current working directory)',
+                                },
+                                files: {
+                                    type: 'array',
+                                    items: { type: 'string' },
+                                    description: 'Specific files to include in diff',
+                                },
+                                base_ref: {
+                                    type: 'string',
+                                    default: 'HEAD',
+                                    description: 'Git reference to compare against (e.g., "HEAD", "main", commit hash)',
+                                },
+                            },
+                            required: ['files'],
+                            description: 'Generate git diff output to include as context. Shows uncommitted changes by default.',
+                        },
+                    },
+                    required: ['files'],
+                },
+            },
+        ],
+    };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    if (request.params.name === 'llm_query') {
+        const { files, model = 'o3', git_diff, } = request.params.arguments;
+        try {
+            // Validate files exist
+            const resolvedFiles = files.map((f) => resolve(f));
+            const missingFiles = resolvedFiles.filter((f) => !existsSync(f));
+            if (missingFiles.length > 0) {
+                throw new Error(`Files not found: ${missingFiles.join(', ')}`);
+            }
+            // Process files using same logic as CLI
+            const markdownFiles = [];
+            const otherFiles = [];
+            for (let i = 0; i < files.length; i++) {
+                const filePath = resolvedFiles[i];
+                const originalPath = files[i];
+                const content = readFileSync(filePath, 'utf-8');
+                if (originalPath.endsWith('.md') ||
+                    originalPath.endsWith('.markdown')) {
+                    markdownFiles.push(content);
+                }
+                else {
+                    otherFiles.push({ path: originalPath, content });
+                }
+            }
+            // Generate git diff if requested
+            let gitDiffOutput = '';
+            if (git_diff) {
+                try {
+                    const repoPath = git_diff.repo_path || process.cwd();
+                    const diffFiles = git_diff.files;
+                    const baseRef = git_diff.base_ref || 'HEAD';
+                    // Build git diff command - always pass specific files to avoid unrelated changes
+                    if (diffFiles.length === 0) {
+                        throw new Error('No files specified for git diff');
+                    }
+                    const gitCommand = `git diff ${baseRef} -- ${diffFiles.join(' ')}`;
+                    gitDiffOutput = execSync(gitCommand, {
+                        cwd: repoPath,
+                        encoding: 'utf-8',
+                        maxBuffer: 1024 * 1024, // 1MB max
+                    });
+                }
+                catch (error) {
+                    gitDiffOutput = `Error generating git diff: ${error instanceof Error ? error.message : String(error)}`;
+                }
+            }
+            // Build prompt using same logic as CLI
+            let promptParts = [];
+            // Add git diff as context if available
+            if (gitDiffOutput.trim()) {
+                promptParts.push('## Git Diff\n');
+                promptParts.push('```diff');
+                promptParts.push(gitDiffOutput);
+                promptParts.push('```\n');
+            }
+            // Add non-markdown files as context
+            if (otherFiles.length > 0) {
+                promptParts.push('## Relevant Files\n');
+                for (const file of otherFiles) {
+                    promptParts.push(`### File: ${file.path}`);
+                    promptParts.push('```');
+                    promptParts.push(file.content);
+                    promptParts.push('```\n');
+                }
+            }
+            // Add markdown files as main prompt
+            if (markdownFiles.length > 0) {
+                promptParts.push(...markdownFiles);
+            }
+            const prompt = promptParts.join('\n');
+            // Log the prompt
+            logToFile(`PROMPT (model: ${model}):\n${prompt}\n${'='.repeat(80)}`);
+            // Send to LLM
+            const { client } = getClientForModel(model);
+            const completion = await client.chat.completions.create({
+                model,
+                messages: [{ role: 'user', content: prompt }],
+            });
+            const response = completion.choices[0]?.message?.content;
+            if (!response) {
+                throw new Error('No response from the model');
+            }
+            // Calculate and log pricing
+            const usage = completion.usage;
+            const { inputCost, outputCost, totalCost } = calculateCost(usage, model);
+            const costInfo = usage
+                ? `Tokens: ${usage.prompt_tokens} input, ${usage.completion_tokens} output | Cost: $${totalCost.toFixed(6)} (input: $${inputCost.toFixed(6)}, output: $${outputCost.toFixed(6)})`
+                : 'Usage data not available';
+            // Log the response with pricing
+            logToFile(`RESPONSE (model: ${model}):\n${response}\n${costInfo}\n${'='.repeat(80)}`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: response,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            throw new Error(`LLM query failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    throw new Error(`Unknown tool: ${request.params.name}`);
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/dist/prompt-builder.d.ts

@@ -0,0 +1,4 @@
+export declare function buildPrompt(markdownFiles: string[], otherFiles: Array<{
+    path: string;
+    content: string;
+}>, gitDiffOutput?: string): string;

package/dist/prompt-builder.js

@@ -0,0 +1,19 @@
+export function buildPrompt(markdownFiles, otherFiles, gitDiffOutput) {
+    const promptParts = [];
+    if (gitDiffOutput?.trim()) {
+        promptParts.push('## Git Diff\n```diff', gitDiffOutput, '```\n');
+    }
+    if (otherFiles.length > 0) {
+        promptParts.push('## Relevant Files\n');
+        for (const file of otherFiles) {
+            promptParts.push(`### File: ${file.path}`);
+            promptParts.push('```');
+            promptParts.push(file.content);
+            promptParts.push('```\n');
+        }
+    }
+    if (markdownFiles.length > 0) {
+        promptParts.push(...markdownFiles);
+    }
+    return promptParts.join('\n');
+}

package/dist/schema.d.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod/v4';
+export declare const SupportedChatModel: z.ZodEnum<{
+    o3: "o3";
+    "gemini-2.5-pro": "gemini-2.5-pro";
+    "deepseek-reasoner": "deepseek-reasoner";
+}>;
+export type SupportedChatModel = z.infer<typeof SupportedChatModel>;
+export declare const ConsultLlmArgs: z.ZodObject<{
+    files: z.ZodArray<z.ZodString>;
+    model: z.ZodOptional<z.ZodEnum<{
+        o3: "o3";
+        "gemini-2.5-pro": "gemini-2.5-pro";
+        "deepseek-reasoner": "deepseek-reasoner";
+    }>>;
+    git_diff: z.ZodOptional<z.ZodObject<{
+        repo_path: z.ZodOptional<z.ZodString>;
+        files: z.ZodArray<z.ZodString>;
+        base_ref: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const toolSchema: {
+    readonly name: "consult_llm";
+    readonly description: "Ask a more powerful AI for help with complex problems. Write your problem description in a markdown file and pass relevant code files as context.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly files: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+                readonly description: "Array of file paths to process. Markdown files (.md) become the main prompt, other files are added as context with file paths and code blocks.";
+            };
+            readonly model: {
+                readonly type: "string";
+                readonly enum: readonly ["o3", "gemini-2.5-pro", "deepseek-reasoner"];
+                readonly default: "o3";
+                readonly description: "LLM model to use";
+            };
+            readonly git_diff: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly repo_path: {
+                        readonly type: "string";
+                        readonly description: "Path to git repository (defaults to current working directory)";
+                    };
+                    readonly files: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "Specific files to include in diff";
+                    };
+                    readonly base_ref: {
+                        readonly type: "string";
+                        readonly default: "HEAD";
+                        readonly description: "Git reference to compare against (e.g., \"HEAD\", \"main\", commit hash)";
+                    };
+                };
+                readonly required: readonly ["files"];
+                readonly description: "Generate git diff output to include as context. Shows uncommitted changes by default.";
+            };
+        };
+        readonly required: readonly ["files"];
+    };
+};

package/dist/schema.js

@@ -0,0 +1,61 @@
+import { z } from 'zod/v4';
+export const SupportedChatModel = z.enum([
+    'o3',
+    'gemini-2.5-pro',
+    'deepseek-reasoner',
+]);
+export const ConsultLlmArgs = z.object({
+    files: z.array(z.string()).min(1, 'At least one file is required'),
+    model: SupportedChatModel.optional(),
+    git_diff: z
+        .object({
+        repo_path: z.string().optional(),
+        files: z
+            .array(z.string())
+            .min(1, 'At least one file is required for git diff'),
+        base_ref: z.string().optional().default('HEAD'),
+    })
+        .optional(),
+});
+export const toolSchema = {
+    name: 'consult_llm',
+    description: 'Ask a more powerful AI for help with complex problems. Write your problem description in a markdown file and pass relevant code files as context.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            files: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Array of file paths to process. Markdown files (.md) become the main prompt, other files are added as context with file paths and code blocks.',
+            },
+            model: {
+                type: 'string',
+                enum: ['o3', 'gemini-2.5-pro', 'deepseek-reasoner'],
+                default: 'o3',
+                description: 'LLM model to use',
+            },
+            git_diff: {
+                type: 'object',
+                properties: {
+                    repo_path: {
+                        type: 'string',
+                        description: 'Path to git repository (defaults to current working directory)',
+                    },
+                    files: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Specific files to include in diff',
+                    },
+                    base_ref: {
+                        type: 'string',
+                        default: 'HEAD',
+                        description: 'Git reference to compare against (e.g., "HEAD", "main", commit hash)',
+                    },
+                },
+                required: ['files'],
+                description: 'Generate git diff output to include as context. Shows uncommitted changes by default.',
+            },
+        },
+        required: ['files'],
+    },
+};

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "consult-llm-mcp",
+  "version": "1.0.0",
+  "description": "MCP server for consulting powerful AI models",
+  "type": "module",
+  "main": "dist/main.js",
+  "bin": {
+    "consult-llm-mcp": "./dist/main.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/main.ts",
+    "start": "node dist/main.js",
+    "format": "prettier --write .",
+    "install-global": "npm run build && npm install -g .",
+    "prepublishOnly": "npm run build",
+    "publish:dry": "npm publish --dry-run",
+    "publish:patch": "npm version patch && npm publish",
+    "publish:minor": "npm version minor && npm publish",
+    "publish:major": "npm version major && npm publish"
+  },
+  "keywords": [
+    "mcp",
+    "openai",
+    "gemini",
+    "llm",
+    "ai"
+  ],
+  "author": "",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/raine/consult-llm-mcp.git"
+  },
+  "homepage": "https://github.com/raine/consult-llm-mcp#readme",
+  "bugs": {
+    "url": "https://github.com/raine/consult-llm-mcp/issues"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.13.0",
+    "openai": "^5.6.0",
+    "zod": "^3.25.67"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.3",
+    "prettier": "^3.5.3",
+    "tsx": "^4.20.3",
+    "typescript": "^5.8.3"
+  }
+}