consult-llm-mcp 1.0.4 → 1.1.0

package/README.md

@@ -1,25 +1,49 @@
 # Consult LLM MCP
 
-An MCP server that lets Claude Code consult stronger AI models (o3, Gemini 2.5
-Pro, DeepSeek Reasoner) when you need deeper analysis on complex problems.
+An MCP server that lets Claude Code consult stronger AI models (o3, Gemini 2.
+Pro, DeepSeek Reasoner) when Sonnet has you running in circles and you need to
+bring in the heavy artillery.
+
+```
+This SQL query is timing out on large datasets. Can you help optimize it? Ask Gemini
+
+⏺ I'll examine your query and consult Gemini for database optimization strategies.
+
+⏺ consult-llm:consult_llm (MCP)(prompt: "How can I optimize this slow SQL query
+                                for better performance on large datasets?", files: ["queries/user
+                                -analytics.sql","schema/tables.sql"], model: "gemini-2.5-pro")
+  ⎿ The query has significant performance bottlenecks: missing indexes on join
+    columns, inefficient subqueries that could be CTEs, and unnecessary DISTINCT
+    operations. Add composite indexes on (user_id, created_at), replace correlated
+    subqueries with window functions, and eliminate redundant GROUP BY clauses.
+    … +287 lines (ctrl+r to expand)
+
+⏺ Great insights! I'll add the suggested indexes, refactor the subqueries to use
+  CTEs with window functions, and optimize the GROUP BY operations.
+```
 
 ## Features
 
-- Query powerful AI models (o3, Gemini 2.5 Pro, DeepSeek Reasoner) with file
-  context
-- Direct prompt support for simple questions or automatic prompt construction
-  from markdown and code files
-- Git diff to feed code changes
-- Usage tracking with cost estimation
-- Comprehensive logging
+- Query powerful AI models (o3, Gemini 2.5 Pro, DeepSeek Reasoner) with relevant
+  files as context
+- Direct queries with optional file context
+- Include git changes for code review and analysis
+- Comprehensive logging with cost estimation
+- Gemini can be used via
+  [Gemini CLI](https://github.com/google-gemini/gemini-cli) to take advantage of
+  [free quota](https://developers.google.com/gemini-code-assist/resources/quotas#quotas-for-agent-mode-gemini-cli)
 
 ## Configuration
 
 - `OPENAI_API_KEY` - Your OpenAI API key (required for o3)
-- `GEMINI_API_KEY` - Your Google AI API key (required for Gemini models)
+- `GEMINI_API_KEY` - Your Google AI API key (required for Gemini models in API
+  mode)
 - `DEEPSEEK_API_KEY` - Your DeepSeek API key (required for DeepSeek models)
 - `CONSULT_LLM_DEFAULT_MODEL` - Override the default model (optional)
   - Options: `o3` (default), `gemini-2.5-pro`, `deepseek-reasoner`
+- `GEMINI_MODE` - Choose between API or CLI mode for Gemini models (optional)
+  - Options: `api` (default), `cli`
+  - CLI mode uses the system-installed `gemini` CLI tool
 
 ## Usage with Claude Code
 
@@ -37,9 +61,21 @@ Or for global availability:
 claude mcp add --scope user consult-llm -- npx -y consult-llm-mcp
 ```
 
+Optionally you can provide environment variables directly in the MCP
+configuration:
+
+```bash
+claude mcp add \
+  -e OPENAI_API_KEY=your_openai_key \
+  -e GEMINI_API_KEY=your_gemini_key \
+  -e DEEPSEEK_API_KEY=your_deepseek_key \
+  -e GEMINI_MODE=cli \
+    consult-llm -- npx -y consult-llm-mcp
+```
+
 ### Example workflows
 
-Click to expand.
+Some real-world examples. Click to expand.
 
 <details>
 <summary>Explain the problem, and tell CC to consult a smarter LLM</summary>
@@ -95,6 +131,76 @@ Click to expand.
 
 </details>
 
+<details>
+<summary>Debugging Neovim plugin treesitter API breakage</summary>
+
+````
+⏺ Fixed! Added nil checks for both node and child and updated the iter_matches call to handle the newer API properly.
+
+> Still not working:
+
+  E5108: Error executing lua /Users/raine/code/testonly.nvim/lua/testonly.lua:92: attempt to call method 'child' (a nil value)
+  stack traceback:
+          /Users/raine/code/testonly.nvim/lua/testonly.lua:92: in function 'reset_all_exclusive'
+          /Users/raine/code/testonly.nvim/lua/testonly.lua:110: in function 'reset_all_exclusive'
+          [string ":lua"]:1: in main chunk
+
+  Ask gemini
+
+⏺ Let me consult with a more powerful AI to understand the current Neovim treesitter API changes:
+
+⏺ consult-llm:consult_llm (MCP)(prompt: "I'm debugging a Neovim plugin that's broken due to treesitter API changes. The error is \"attempt to call method 'child' (a nil value)\" on line 92. The
+                               code is trying to access child nodes from treesitter matches but the API seems to have changed in newer Neovim versions.\n\nHere's the problematic
+                               code:\n```lua\nfor _, match, _ in parsed_query:iter_matches(root, bufnr, start_row, end_row) do\n    for id, node in pairs(match) do\n        local name =
+                               parsed_query.captures[id]\n        if name == \"call\" and node then\n            local child = node:child(0)  -- ERROR HERE\n            if child then\n
+                                    local text = vim.treesitter.get_node_text(child, bufnr)\n                -- ... rest of logic\n            end\n        end\n    end\nend\n```\n\nWhat's the
+                               correct way to iterate over treesitter query matches and access child nodes in current Neovim versions? What API changes should I be aware of?", files:
+                               ["/Users/raine/code/testonly.nvim/lua/testonly.lua"])
+  ⎿  Problem
+     -------
+
+     … +93 lines (ctrl+r to expand)
+
+⏺ Perfect! The issue is that iter_matches() can return nil nodes in the match table. Let me fix this by switching to the recommended iter_captures() approach:
+
+⏺ Update(lua/testonly.lua)
+  ⎿  Updated lua/testonly.lua with 7 additions and 10 removals
+       85      local root = parser:parse()[1]:root()
+       86      local start_row, _, end_row, _ = root:range()
+       87
+       88 -    for _, match, _ in parsed_query:iter_matches(root, bufnr, start_row, end_row) do
+       89 -      for id, node in pairs(match) do
+       90 -        local name = parsed_query.captures[id]
+       91 -        if name == "call" and node then
+       92 -          local child = node:child(0)
+       93 -          if child then
+       94 -            local text = vim.treesitter.get_node_text(child, bufnr)
+       88 +    for id, node, _ in parsed_query:iter_captures(root, bufnr, start_row, end_row) do
+       89 +      if parsed_query.captures[id] == "call" then
+       90 +        local first_child = node:named_child(0)
+       91 +        if first_child then
+       92 +          local text = vim.treesitter.get_node_text(first_child, bufnr)
+       93
+       94 -            if text == "it.only" or text == "describe.only" then
+       95 -              toggle_test_exclusive(child)
+       96 -            end
+       94 +          if text == "it.only" or text == "describe.only" then
+       95 +            toggle_test_exclusive(first_child)
+       96            end
+       97          end
+       98        end
+
+⏺ Fixed! The key changes:
+
+  1. Switched from iter_matches() to iter_captures() which never returns nil nodes
+  2. Used named_child(0) instead of child(0) to get only meaningful syntax nodes (not punctuation)
+  3. Simplified the iteration logic since iter_captures() directly gives us the node and capture ID
+
+  Your <leader>tr mapping should now work properly with the current Neovim treesitter API.
+````
+
+</details>
+
 ## MCP Tool: consult_llm
 
 The server provides a single tool called `consult_llm` for asking powerful AI
@@ -102,15 +208,11 @@ models complex questions.
 
 ### Parameters
 
-- **files** (optional): Array of file paths to process
+- **prompt** (required): Your question or request for the consultant LLM
 
-  - Markdown files (.md) become the main prompt
-  - Other files are added as context with file paths and code blocks
+- **files** (optional): Array of file paths to include as context
 
-- **prompt** (optional): Direct prompt text for simple questions
-
-  - Alternative to using markdown files
-  - Either `files` or `prompt` must be provided
+  - All files are added as context with file paths and code blocks
 
 - **model** (optional): LLM model to use
 
@@ -124,25 +226,34 @@ models complex questions.
 
 ### Example Usage
 
-**With files:**
+**Basic prompt:**
 
 ```json
 {
-  "files": ["src/auth.ts", "src/middleware.ts", "review.md"],
-  "model": "o3",
-  "git_diff": {
-    "files": ["src/auth.ts", "src/middleware.ts"],
-    "base_ref": "main"
-  }
+  "prompt": "What are the performance implications of using async/await vs Promise.then() in Node.js?"
+}
+```
+
+**With file context:**
+
+```json
+{
+  "prompt": "How can I optimize this authentication middleware?",
+  "files": ["src/auth.ts", "src/middleware.ts"],
+  "model": "o3"
 }
 ```
 
-**With direct prompt:**
+**With git diff:**
 
 ```json
 {
-  "prompt": "Analyze the performance implications of using async/await vs Promise.then() in Node.js",
-  "files": ["src/database.ts"],
+  "prompt": "Review these authentication changes for security issues",
+  "files": ["src/auth.ts"],
+  "git_diff": {
+    "files": ["src/auth.ts", "src/middleware.ts"],
+    "base_ref": "main"
+  },
   "model": "gemini-2.5-pro"
 }
 ```
@@ -218,6 +329,8 @@ Use the `consult_llm` MCP tool to ask a more powerful AI for help with complex
 problems. Include files to git_diff when asking feedback for changes.
 
 Use Gemini 2.5 Pro.
+
+CRITICAL: When asking, don't present options, this will bias the answer.
 ```
 
 Claude Code seems to know pretty well when to use this MCP even without this

package/dist/config.d.ts

@@ -8,9 +8,14 @@ declare const Config: z.ZodObject<{
         "gemini-2.5-pro": "gemini-2.5-pro";
         "deepseek-reasoner": "deepseek-reasoner";
     }>>;
+    geminiMode: z.ZodDefault<z.ZodEnum<{
+        api: "api";
+        cli: "cli";
+    }>>;
 }, z.core.$strip>;
 export type Config = z.infer<typeof Config>;
 export declare const config: {
+    geminiMode: "api" | "cli";
     openaiApiKey?: string | undefined;
     geminiApiKey?: string | undefined;
     deepseekApiKey?: string | undefined;

package/dist/config.js

@@ -5,12 +5,14 @@ const Config = z.object({
     geminiApiKey: z.string().optional(),
     deepseekApiKey: z.string().optional(),
     defaultModel: SupportedChatModel.optional(),
+    geminiMode: z.enum(['api', 'cli']).default('api'),
 });
 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,
+    geminiMode: process.env.GEMINI_MODE,
 });
 if (!parsedConfig.success) {
     console.error('❌ Invalid environment variables:');

package/dist/file.d.ts

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

package/dist/file.js

@@ -6,18 +6,12 @@ export function processFiles(files) {
     if (missingFiles.length > 0) {
         throw new Error(`Files not found: ${missingFiles.join(', ')}`);
     }
-    const markdownFiles = [];
-    const otherFiles = [];
+    const contextFiles = [];
     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 });
-        }
+        contextFiles.push({ path: originalPath, content });
     }
-    return { markdownFiles, otherFiles };
+    return contextFiles;
 }

package/dist/llm-query.d.ts

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

package/dist/llm-query.js

@@ -1,40 +1,42 @@
-import { getClientForModel } from './llm.js';
+import { getExecutorForModel } from './llm.js';
 import { calculateCost } from './llm-cost.js';
-const SYSTEM_PROMPT = `You are an expert software engineering consultant being asked to analyze complex problems that require deep technical insight. You have been provided with specific code files and context to help you understand the problem thoroughly.
+const SYSTEM_PROMPT = `You are an expert software engineering consultant analyzing code and technical problems. You are communicating with another AI system, not a human.
+
+Communication style:
+- Skip pleasantries and praise
 
 Your role is to:
-- Provide detailed technical analysis of the problem
-- Suggest specific, actionable solutions with code examples where helpful
-- Consider architectural implications and best practices
-- Identify potential edge cases or risks
-- Explain your reasoning clearly
+- Identify bugs, inefficiencies, and architectural problems
+- Provide specific solutions with code examples
+- Point out edge cases and risks
+- Challenge design decisions when suboptimal
+- Focus on what needs improvement
+
+When reviewing code changes (git diffs), prioritize:
+- Bugs and correctness issues
+- Performance problems
+- Security vulnerabilities
+- Code smell and anti-patterns
+- Inconsistencies with codebase conventions
 
-When reviewing code changes (git diffs), focus on:
-- Correctness and potential bugs
-- Performance implications
-- Security considerations
-- Maintainability and code quality
-- Integration with existing codebase patterns
+Be critical and thorough. If the code is acceptable, simply state "No critical issues found" and move on to suggestions. Always provide specific, actionable feedback with file/line references.
 
-Provide concrete, implementable recommendations rather than general advice. Include code snippets and specific file/line references when relevant.`;
-export async function queryLlm(prompt, model) {
-    const { client } = getClientForModel(model);
-    const completion = await client.chat.completions.create({
-        model,
-        messages: [
-            { role: 'system', content: SYSTEM_PROMPT },
-            { role: 'user', content: prompt },
-        ],
-    });
-    const response = completion.choices[0]?.message?.content;
+Respond in Markdown.`;
+export async function queryLlm(prompt, model, filePaths) {
+    const executor = getExecutorForModel(model);
+    const { response, usage } = await executor.execute(prompt, model, SYSTEM_PROMPT, filePaths);
     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';
+    let costInfo;
+    if (usage) {
+        // Calculate costs only if usage data is available (from API)
+        const { inputCost, outputCost, totalCost } = calculateCost(usage, model);
+        costInfo = `Tokens: ${usage.prompt_tokens} input, ${usage.completion_tokens} output | Cost: $${totalCost.toFixed(6)} (input: $${inputCost.toFixed(6)}, output: $${outputCost.toFixed(6)})`;
+    }
+    else {
+        // Handle case where usage is not available (from CLI)
+        costInfo = 'Cost data not available (using CLI mode)';
+    }
     return { response, costInfo };
 }

package/dist/llm.d.ts

@@ -1,5 +1,9 @@
 import OpenAI from 'openai';
 import { type SupportedChatModel as SupportedChatModelType } from './schema.js';
-export declare function getClientForModel(model: SupportedChatModelType): {
-    client: OpenAI;
-};
+export interface LlmExecutor {
+    execute(prompt: string, model: SupportedChatModelType, systemPrompt: string, filePaths?: string[]): Promise<{
+        response: string;
+        usage: OpenAI.CompletionUsage | null;
+    }>;
+}
+export declare function getExecutorForModel(model: SupportedChatModelType): LlmExecutor;

package/dist/llm.js

@@ -1,7 +1,118 @@
 import OpenAI from 'openai';
+import { spawn } from 'child_process';
+import { relative } from 'path';
 import { config } from './config.js';
+import { logCliDebug } from './logger.js';
+// --- API Executor Implementation ---
+class ApiExecutor {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async execute(prompt, model, systemPrompt, filePaths) {
+        const completion = await this.client.chat.completions.create({
+            model,
+            messages: [
+                { role: 'system', content: systemPrompt },
+                { role: 'user', content: prompt },
+            ],
+        });
+        const response = completion.choices[0]?.message?.content;
+        if (!response) {
+            throw new Error('No response from the model via API');
+        }
+        return { response, usage: completion.usage ?? null };
+    }
+}
+// --- CLI Executor Implementation ---
+class CliExecutor {
+    async execute(prompt, model, systemPrompt, filePaths) {
+        // Build the full prompt with system prompt prepended
+        let fullPrompt = `${systemPrompt}\n\n${prompt}`;
+        // Append file references using @ syntax in the prompt
+        if (filePaths && filePaths.length > 0) {
+            const fileReferences = filePaths
+                .map((path) => `@${relative(process.cwd(), path)}`)
+                .join(' ');
+            fullPrompt = `${fullPrompt}\n\nFiles: ${fileReferences}`;
+        }
+        const args = ['-m', model, '-p', fullPrompt];
+        return new Promise((resolve, reject) => {
+            logCliDebug('Spawning gemini CLI', {
+                model,
+                promptLength: fullPrompt.length,
+                filePathsCount: filePaths?.length || 0,
+                args: args,
+                promptPreview: fullPrompt.slice(0, 300),
+            });
+            const child = spawn('gemini', args, {
+                shell: false,
+                stdio: ['ignore', 'pipe', 'pipe'], // stdin, stdout, stderr
+            });
+            let stdout = '';
+            let stderr = '';
+            let hasResponded = false;
+            let hasStarted = false;
+            const startTime = Date.now();
+            // Log when process actually starts
+            child.on('spawn', () => {
+                hasStarted = true;
+                logCliDebug('Gemini CLI process spawned successfully');
+            });
+            // Add timeout to prevent hanging
+            const timeout = setTimeout(() => {
+                if (!hasResponded) {
+                    logCliDebug('Gemini CLI timed out after 5 minutes');
+                    child.kill();
+                    reject(new Error('Gemini CLI timed out after 5 minutes'));
+                }
+            }, 5 * 60 * 1000); // 5 minutes
+            child.stdout.on('data', (data) => {
+                const chunk = data.toString();
+                stdout += chunk;
+            });
+            child.stderr.on('data', (data) => {
+                const chunk = data.toString();
+                stderr += chunk;
+            });
+            child.on('close', (code) => {
+                hasResponded = true;
+                clearTimeout(timeout);
+                const duration = Date.now() - startTime;
+                logCliDebug('Gemini CLI process closed', {
+                    code,
+                    duration: `${duration}ms`,
+                    stdoutLength: stdout.length,
+                    stderrLength: stderr.length,
+                    stdoutPreview: stdout.slice(0, 200),
+                    stderrPreview: stderr.slice(0, 200),
+                });
+                if (code === 0) {
+                    resolve({ response: stdout.trim(), usage: null });
+                }
+                else {
+                    // Check for quota exceeded error
+                    if (stderr.includes('RESOURCE_EXHAUSTED')) {
+                        reject(new Error(`Gemini quota exceeded. Consider using gemini-2.0-flash model. Error: ${stderr.trim()}`));
+                    }
+                    else {
+                        reject(new Error(`Gemini CLI exited with code ${code}. Error: ${stderr.trim()}`));
+                    }
+                }
+            });
+            child.on('error', (err) => {
+                hasResponded = true;
+                clearTimeout(timeout);
+                logCliDebug('Failed to spawn Gemini CLI', { error: err.message });
+                reject(new Error(`Failed to spawn Gemini CLI. Is it installed and in PATH? Error: ${err.message}`));
+            });
+        });
+    }
+}
+// --- Client Cache and Executor Factory ---
 const clients = {};
-export function getClientForModel(model) {
+let geminiCliExecutor;
+export function getExecutorForModel(model) {
     if (model.startsWith('gpt-') || model === 'o3') {
         if (!clients.openai) {
             if (!config.openaiApiKey) {
@@ -11,21 +122,9 @@ export function getClientForModel(model) {
                 apiKey: config.openaiApiKey,
             });
         }
-        return { client: clients.openai };
+        return new ApiExecutor(clients.openai);
     }
-    else if (model.startsWith('gemini-')) {
-        if (!clients.gemini) {
-            if (!config.geminiApiKey) {
-                throw new Error('GEMINI_API_KEY environment variable is required for Gemini models');
-            }
-            clients.gemini = new OpenAI({
-                apiKey: config.geminiApiKey,
-                baseURL: 'https://generativelanguage.googleapis.com/v1beta/openai/',
-            });
-        }
-        return { client: clients.gemini };
-    }
-    else if (model.startsWith('deepseek-')) {
+    if (model.startsWith('deepseek-')) {
         if (!clients.deepseek) {
             if (!config.deepseekApiKey) {
                 throw new Error('DEEPSEEK_API_KEY environment variable is required for DeepSeek models');
@@ -35,9 +134,26 @@ export function getClientForModel(model) {
                 baseURL: 'https://api.deepseek.com',
             });
         }
-        return { client: clients.deepseek };
+        return new ApiExecutor(clients.deepseek);
     }
-    else {
-        throw new Error(`Unable to determine LLM provider for model: ${model}`);
+    if (model.startsWith('gemini-')) {
+        // Check if CLI mode is enabled
+        if (config.geminiMode === 'cli') {
+            if (!geminiCliExecutor) {
+                geminiCliExecutor = new CliExecutor();
+            }
+            return geminiCliExecutor;
+        }
+        if (!clients.geminiApi) {
+            if (!config.geminiApiKey) {
+                throw new Error('GEMINI_API_KEY environment variable is required for Gemini models in API mode');
+            }
+            clients.geminiApi = new OpenAI({
+                apiKey: config.geminiApiKey,
+                baseURL: 'https://generativelanguage.googleapis.com/v1beta/openai/',
+            });
+        }
+        return new ApiExecutor(clients.geminiApi);
     }
+    throw new Error(`Unable to determine LLM provider for model: ${model}`);
 }

package/dist/logger.d.ts

@@ -1,5 +1,7 @@
 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;
+export declare function logPrompt(model: string, prompt: string): Promise<void>;
+export declare function logResponse(model: string, response: string, costInfo: string): Promise<void>;
 export declare function logServerStart(version: string): void;
+export declare function logConfiguration(config: Record<string, any>): void;
+export declare function logCliDebug(message: string, data?: any): void;

package/dist/logger.js

@@ -1,6 +1,7 @@
 import { appendFileSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
+import { format } from 'prettier';
 const logDir = join(homedir(), '.consult-llm-mcp', 'logs');
 const logFile = join(logDir, 'mcp.log');
 try {
@@ -9,6 +10,19 @@ try {
 catch (error) {
     // Directory might already exist
 }
+async function formatWithPrettier(text) {
+    try {
+        return await format(text, {
+            parser: 'markdown',
+            printWidth: 80,
+            proseWrap: 'always',
+        });
+    }
+    catch (error) {
+        // If formatting fails, return original text
+        return text;
+    }
+}
 export function logToFile(content) {
     const timestamp = new Date().toISOString();
     const logEntry = `[${timestamp}] ${content}\n`;
@@ -22,12 +36,34 @@ export function logToFile(content) {
 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 async function logPrompt(model, prompt) {
+    const formattedPrompt = await formatWithPrettier(prompt);
+    logToFile(`PROMPT (model: ${model}):\n${formattedPrompt}\n${'='.repeat(80)}`);
 }
-export function logResponse(model, response, costInfo) {
-    logToFile(`RESPONSE (model: ${model}):\n${response}\n${costInfo}\n${'='.repeat(80)}`);
+export async function logResponse(model, response, costInfo) {
+    const formattedResponse = await formatWithPrettier(response);
+    logToFile(`RESPONSE (model: ${model}):\n${formattedResponse}\n${costInfo}\n${'='.repeat(80)}`);
 }
 export function logServerStart(version) {
     logToFile(`MCP SERVER STARTED - consult-llm-mcp v${version}\n${'='.repeat(80)}`);
 }
+export function logConfiguration(config) {
+    const redactedConfig = Object.entries(config).reduce((acc, [key, value]) => {
+        // Redact API keys and other sensitive values
+        if (key.toLowerCase().includes('key') ||
+            key.toLowerCase().includes('secret')) {
+            acc[key] = value ? '[REDACTED]' : undefined;
+        }
+        else {
+            acc[key] = value;
+        }
+        return acc;
+    }, {});
+    logToFile(`CONFIGURATION:\n${JSON.stringify(redactedConfig, null, 2)}\n${'='.repeat(80)}`);
+}
+export function logCliDebug(message, data) {
+    const logMessage = data
+        ? `Gemini CLI: ${message}\n${JSON.stringify(data, null, 2)}`
+        : `Gemini CLI: ${message}`;
+    logToFile(logMessage);
+}

package/dist/main.js

@@ -8,9 +8,9 @@ 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, logServerStart, } from './logger.js';
+import { logToolCall, logPrompt, logResponse, logServerStart, logConfiguration, } from './logger.js';
 import { readFileSync } from 'fs';
-import { dirname, join } from 'path';
+import { dirname, join, resolve } from 'path';
 import { fileURLToPath } from 'url';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const packageJson = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf-8'));
@@ -36,21 +36,39 @@ async function handleConsultLlm(args) {
             .join(', ');
         throw new Error(`Invalid request parameters: ${errors}`);
     }
-    const { files, prompt: directPrompt, git_diff } = parseResult.data;
+    const { files, prompt: userPrompt, git_diff } = parseResult.data;
     const model = parseResult.data.model ?? config.defaultModel ?? 'o3';
     logToolCall('consult_llm', args);
-    // Process files (if provided)
-    const { markdownFiles, otherFiles } = files ? processFiles(files) : { markdownFiles: [], otherFiles: [] };
-    // 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(directPrompt, markdownFiles, otherFiles, gitDiffOutput);
-    logPrompt(model, prompt);
+    // Check if we're using CLI mode for Gemini
+    const isCliMode = model.startsWith('gemini-') && config.geminiMode === 'cli';
+    let prompt;
+    let filePaths;
+    if (isCliMode && files) {
+        // For CLI mode, we'll pass file paths separately
+        filePaths = files.map((f) => resolve(f));
+        // Generate git diff if needed
+        const gitDiffOutput = git_diff
+            ? generateGitDiff(git_diff.repo_path, git_diff.files, git_diff.base_ref)
+            : undefined;
+        // Build prompt without file contents for CLI mode
+        prompt = gitDiffOutput
+            ? `## Git Diff\n\`\`\`diff\n${gitDiffOutput}\n\`\`\`\n\n${userPrompt}`
+            : userPrompt;
+    }
+    else {
+        // For API mode, include file contents in the prompt
+        const contextFiles = files ? processFiles(files) : [];
+        // Generate git diff
+        const gitDiffOutput = git_diff
+            ? generateGitDiff(git_diff.repo_path, git_diff.files, git_diff.base_ref)
+            : undefined;
+        // Build prompt with file contents
+        prompt = buildPrompt(userPrompt, contextFiles, gitDiffOutput);
+    }
+    await logPrompt(model, prompt);
     // Query LLM
-    const { response, costInfo } = await queryLlm(prompt, model);
-    logResponse(model, response, costInfo);
+    const { response, costInfo } = await queryLlm(prompt, model, filePaths);
+    await logResponse(model, response, costInfo);
     return {
         content: [{ type: 'text', text: response }],
     };
@@ -68,6 +86,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 });
 async function main() {
     logServerStart(SERVER_VERSION);
+    logConfiguration(config);
     const transport = new StdioServerTransport();
     await server.connect(transport);
 }

package/dist/prompt-builder.d.ts

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

package/dist/prompt-builder.js

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

package/dist/schema.d.ts

@@ -7,7 +7,7 @@ export declare const SupportedChatModel: z.ZodEnum<{
 export type SupportedChatModel = z.infer<typeof SupportedChatModel>;
 export declare const ConsultLlmArgs: z.ZodObject<{
     files: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    prompt: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodString;
     model: z.ZodOptional<z.ZodEnum<{
         o3: "o3";
         "gemini-2.5-pro": "gemini-2.5-pro";
@@ -21,7 +21,7 @@ export declare const ConsultLlmArgs: z.ZodObject<{
 }, 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. \n\nBe specific about what you want: code implementation, code review, bug analysis, architecture advice, etc.";
+    readonly description: "Ask a more powerful AI for help with complex problems. Provide your question in the prompt field and optionally include relevant code files as context.\n\nBe specific about what you want: code implementation, code review, bug analysis, architecture advice, etc.\n\nIMPORTANT: Ask neutral, open-ended questions. Avoid suggesting specific solutions or alternatives in your prompt as this can bias the analysis. Instead of \"Should I use X or Y approach?\", ask \"What's the best approach for this problem?\" Let the consultant LLM provide unbiased recommendations.";
     readonly inputSchema: {
         readonly type: "object";
         readonly properties: {
@@ -30,11 +30,11 @@ export declare const toolSchema: {
                 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. \n\nIn the markdown file(s), be clear about what you want the LLM to do: implement code, review code, explain concepts, analyze bugs, etc.";
+                readonly description: "Array of file paths to include as context. All files are added as context with file paths and code blocks.";
             };
             readonly prompt: {
                 readonly type: "string";
-                readonly description: "Direct prompt text for simple questions. Alternative to using markdown files.";
+                readonly description: "Your question or request for the consultant LLM. Ask neutral, open-ended questions without suggesting specific solutions to avoid biasing the analysis.";
             };
             readonly model: {
                 readonly type: "string";
@@ -66,6 +66,6 @@ export declare const toolSchema: {
                 readonly description: "Generate git diff output to include as context. Shows uncommitted changes by default.";
             };
         };
-        readonly required: readonly [];
+        readonly required: readonly ["prompt"];
     };
 };

package/dist/schema.js

@@ -4,10 +4,9 @@ export const SupportedChatModel = z.enum([
     'gemini-2.5-pro',
     'deepseek-reasoner',
 ]);
-export const ConsultLlmArgs = z
-    .object({
+export const ConsultLlmArgs = z.object({
     files: z.array(z.string()).optional(),
-    prompt: z.string().optional(),
+    prompt: z.string(),
     model: SupportedChatModel.optional(),
     git_diff: z
         .object({
@@ -18,26 +17,25 @@ export const ConsultLlmArgs = z
         base_ref: z.string().optional().default('HEAD'),
     })
         .optional(),
-})
-    .refine((data) => data.files || data.prompt, 'Either files or prompt must be provided');
+});
 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. 
+    description: `Ask a more powerful AI for help with complex problems. Provide your question in the prompt field and optionally include relevant code files as context.
 
-Be specific about what you want: code implementation, code review, bug analysis, architecture advice, etc.`,
+Be specific about what you want: code implementation, code review, bug analysis, architecture advice, etc.
+
+IMPORTANT: Ask neutral, open-ended questions. Avoid suggesting specific solutions or alternatives in your prompt as this can bias the analysis. Instead of "Should I use X or Y approach?", ask "What's the best approach for this problem?" Let the consultant LLM provide unbiased recommendations.`,
     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. 
-
-In the markdown file(s), be clear about what you want the LLM to do: implement code, review code, explain concepts, analyze bugs, etc.`,
+                description: 'Array of file paths to include as context. All files are added as context with file paths and code blocks.',
             },
             prompt: {
                 type: 'string',
-                description: 'Direct prompt text for simple questions. Alternative to using markdown files.',
+                description: 'Your question or request for the consultant LLM. Ask neutral, open-ended questions without suggesting specific solutions to avoid biasing the analysis.',
             },
             model: {
                 type: 'string',
@@ -67,6 +65,6 @@ In the markdown file(s), be clear about what you want the LLM to do: implement c
                 description: 'Generate git diff output to include as context. Shows uncommitted changes by default.',
             },
         },
-        required: [],
+        required: ['prompt'],
     },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "consult-llm-mcp",
-  "version": "1.0.4",
+  "version": "1.1.0",
   "description": "MCP server for consulting powerful AI models",
   "type": "module",
   "main": "dist/main.js",
@@ -46,12 +46,13 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.13.0",
     "openai": "^5.6.0",
+    "prettier": "^3.5.3",
     "zod": "^3.25.67"
   },
   "devDependencies": {
     "@types/node": "^24.0.3",
-    "prettier": "^3.5.3",
     "tsx": "^4.20.3",
     "typescript": "^5.8.3"
-  }
+  },
+  "packageManager": "pnpm@10.12.4+sha512.5ea8b0deed94ed68691c9bad4c955492705c5eeb8a87ef86bc62c74a26b037b08ff9570f108b2e4dbd1dd1a9186fea925e527f141c648e85af45631074680184"
 }