@brenoxp/gemini-mcp 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Breno Pinto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,104 @@
+# gemini-mcp
+
+MCP server that wraps [Gemini CLI](https://github.com/google-gemini/gemini-cli) for use with Claude Code and other MCP clients.
+
+Use Gemini's large context window (1M tokens) and web search from within Claude Code.
+
+## Prerequisites
+
+- [Gemini CLI](https://github.com/google-gemini/gemini-cli) installed and authenticated
+- Node.js 18+ or Bun
+
+## Installation
+
+### Via npm (recommended)
+
+```bash
+npm install -g @brenoxp/gemini-mcp
+```
+
+### From source
+
+```bash
+git clone https://github.com/brenoxp/gemini-mcp.git
+cd gemini-mcp
+npm install
+npm run build
+```
+
+## Usage with Claude Code
+
+Add to your Claude Code MCP configuration:
+
+```bash
+# If installed globally via npm
+claude mcp add gemini-mcp -- gemini-mcp
+
+# Or run directly with npx
+claude mcp add gemini-mcp -- npx @brenoxp/gemini-mcp
+
+# Or from source
+claude mcp add gemini-mcp -- node /path/to/gemini-mcp/dist/index.js
+```
+
+## Tools
+
+### gemini
+
+Send a prompt directly to Gemini CLI.
+
+Parameters:
+- `prompt` (required): The prompt to send
+- `model`: Gemini model to use (default: `gemini-2.5-flash`)
+- `allowed_tools`: Comma-separated tools Gemini can use (e.g., `web_search,shell`)
+
+### gemini_with_agent_md
+
+Send a prompt with an agent.md file as context. Useful for delegating tasks that need specific instructions.
+
+Parameters:
+- `agent_md_path` (required): Absolute path to agent.md file
+- `prompt` (required): The prompt to send
+- `model`: Override model (otherwise inferred from frontmatter)
+- `allowed_tools`: Comma-separated tools Gemini can use
+
+Model mapping from Claude agent.md frontmatter:
+- `haiku` -> `gemini-2.5-flash-lite`
+- `sonnet` -> `gemini-2.5-flash`
+- `opus` -> `gemini-2.5-pro`
+
+The tool automatically strips frontmatter from the agent.md before passing to Gemini.
+
+## Example prompts in Claude Code
+
+```
+Use the gemini tool to summarize this 500-page PDF: /path/to/large.pdf
+
+Use gemini with web_search to find the latest React 19 features
+
+Use gemini_with_agent_md with my research agent to investigate this topic
+```
+
+## Why use this?
+
+- Gemini has 1M token context - process huge files Claude can't handle in one shot
+- Web search built into Gemini CLI
+- Delegate cheap/simple tasks to Gemini, save Claude tokens for complex reasoning
+- Run agents defined in agent.md files through Gemini
+
+## Development
+
+```bash
+# Run directly with Bun
+bun run dev
+
+# Type check
+npm run typecheck
+
+# Build for distribution
+npm run build
+```
+
+## License
+
+MIT

package/dist/__tests__/frontmatter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/frontmatter.test.js

@@ -0,0 +1,82 @@
+import { describe, it, expect } from "vitest";
+import { extractModelFromFrontmatter, stripFrontmatter } from "../utils/frontmatter.js";
+describe("extractModelFromFrontmatter", () => {
+    it("extracts haiku model", () => {
+        const content = `---
+model: haiku
+---
+# Agent`;
+        expect(extractModelFromFrontmatter(content)).toBe("gemini-2.5-flash-lite");
+    });
+    it("extracts sonnet model", () => {
+        const content = `---
+model: sonnet
+---
+# Agent`;
+        expect(extractModelFromFrontmatter(content)).toBe("gemini-2.5-flash");
+    });
+    it("extracts opus model", () => {
+        const content = `---
+model: opus
+---
+# Agent`;
+        expect(extractModelFromFrontmatter(content)).toBe("gemini-2.5-pro");
+    });
+    it("returns null for unknown model", () => {
+        const content = `---
+model: gpt-4
+---
+# Agent`;
+        expect(extractModelFromFrontmatter(content)).toBeNull();
+    });
+    it("returns null when no frontmatter", () => {
+        const content = `# Agent
+Some content`;
+        expect(extractModelFromFrontmatter(content)).toBeNull();
+    });
+    it("returns null when no model in frontmatter", () => {
+        const content = `---
+title: My Agent
+---
+# Agent`;
+        expect(extractModelFromFrontmatter(content)).toBeNull();
+    });
+    it("handles model with extra whitespace", () => {
+        const content = `---
+model:   haiku
+---
+# Agent`;
+        expect(extractModelFromFrontmatter(content)).toBe("gemini-2.5-flash-lite");
+    });
+});
+describe("stripFrontmatter", () => {
+    it("removes frontmatter", () => {
+        const content = `---
+model: sonnet
+title: My Agent
+---
+# Agent
+Content here`;
+        expect(stripFrontmatter(content)).toBe("# Agent\nContent here");
+    });
+    it("preserves content without frontmatter", () => {
+        const content = `# Agent
+Content here`;
+        expect(stripFrontmatter(content)).toBe(content);
+    });
+    it("handles empty content", () => {
+        expect(stripFrontmatter("")).toBe("");
+    });
+    it("handles frontmatter only", () => {
+        const content = `---
+model: haiku
+---`;
+        expect(stripFrontmatter(content)).toBe("");
+    });
+    it("handles unclosed frontmatter", () => {
+        const content = `---
+model: haiku
+# Agent`;
+        expect(stripFrontmatter(content)).toBe(content);
+    });
+});

package/dist/__tests__/gemini-executor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/gemini-executor.test.js

@@ -0,0 +1,131 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { spawn } from "child_process";
+import { EventEmitter } from "events";
+import { executeGemini, DEFAULT_GEMINI_MODEL, DEFAULT_TOOLS } from "../utils/gemini-executor.js";
+vi.mock("child_process", () => ({
+    spawn: vi.fn(),
+}));
+const mockSpawn = spawn;
+function createMockProcess(exitCode = 0, stdout = "", stderr = "") {
+    const proc = new EventEmitter();
+    const stdinChunks = [];
+    proc.stdin = {
+        write: vi.fn((chunk) => stdinChunks.push(chunk)),
+        end: vi.fn(),
+        _chunks: stdinChunks,
+    };
+    proc.stdout = new EventEmitter();
+    proc.stderr = new EventEmitter();
+    setImmediate(() => {
+        proc.stdout?.emit("data", Buffer.from(stdout));
+        proc.stderr?.emit("data", Buffer.from(stderr));
+        proc.emit("close", exitCode);
+    });
+    return proc;
+}
+describe("executeGemini", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it("spawns gemini with correct base args", async () => {
+        const mockProc = createMockProcess(0, '{"response": "test"}');
+        mockSpawn.mockReturnValue(mockProc);
+        await executeGemini({ prompt: "hello" });
+        expect(mockSpawn).toHaveBeenCalledWith("gemini", expect.arrayContaining([
+            "-s",
+            "--model", DEFAULT_GEMINI_MODEL,
+            "--output-format", "json",
+            "-p", "hello",
+        ]), expect.any(Object));
+    });
+    it("uses custom model when provided", async () => {
+        const mockProc = createMockProcess(0, '{"response": "test"}');
+        mockSpawn.mockReturnValue(mockProc);
+        await executeGemini({ prompt: "hello", model: "gemini-2.5-pro" });
+        expect(mockSpawn).toHaveBeenCalledWith("gemini", expect.arrayContaining(["--model", "gemini-2.5-pro"]), expect.any(Object));
+    });
+    it("includes default tools in allowed-tools", async () => {
+        const mockProc = createMockProcess(0, '{"response": "test"}');
+        mockSpawn.mockReturnValue(mockProc);
+        await executeGemini({ prompt: "hello" });
+        const args = mockSpawn.mock.calls[0][1];
+        const toolsIndex = args.indexOf("--allowed-tools");
+        const toolsValue = args[toolsIndex + 1];
+        for (const tool of DEFAULT_TOOLS) {
+            expect(toolsValue).toContain(tool);
+        }
+    });
+    it("merges user tools with default tools", async () => {
+        const mockProc = createMockProcess(0, '{"response": "test"}');
+        mockSpawn.mockReturnValue(mockProc);
+        await executeGemini({ prompt: "hello", allowedTools: "perplexity_search,shell" });
+        const args = mockSpawn.mock.calls[0][1];
+        const toolsIndex = args.indexOf("--allowed-tools");
+        const toolsValue = args[toolsIndex + 1];
+        expect(toolsValue).toContain("read_file");
+        expect(toolsValue).toContain("write_file");
+        expect(toolsValue).toContain("perplexity_search");
+        expect(toolsValue).toContain("shell");
+    });
+    it("deduplicates tools", async () => {
+        const mockProc = createMockProcess(0, '{"response": "test"}');
+        mockSpawn.mockReturnValue(mockProc);
+        await executeGemini({ prompt: "hello", allowedTools: "read_file,shell" });
+        const args = mockSpawn.mock.calls[0][1];
+        const toolsIndex = args.indexOf("--allowed-tools");
+        const toolsValue = args[toolsIndex + 1];
+        const tools = toolsValue.split(",");
+        const readFileCount = tools.filter((t) => t === "read_file").length;
+        expect(readFileCount).toBe(1);
+    });
+    it("pipes content to stdin when pipeContent provided", async () => {
+        const mockProc = createMockProcess(0, '{"response": "test"}');
+        mockSpawn.mockReturnValue(mockProc);
+        const agentContent = "# Agent\nDo stuff";
+        await executeGemini({ prompt: "hello", pipeContent: agentContent });
+        expect(mockSpawn).toHaveBeenCalledWith("gemini", expect.any(Array), { stdio: ["pipe", "pipe", "pipe"] });
+        expect(mockProc.stdin?.write).toHaveBeenCalledWith(agentContent);
+        expect(mockProc.stdin?.end).toHaveBeenCalled();
+    });
+    it("sets stdin to ignore when no pipeContent", async () => {
+        const mockProc = createMockProcess(0, '{"response": "test"}');
+        mockSpawn.mockReturnValue(mockProc);
+        await executeGemini({ prompt: "hello" });
+        expect(mockSpawn).toHaveBeenCalledWith("gemini", expect.any(Array), { stdio: ["ignore", "pipe", "pipe"] });
+    });
+    it("extracts response from JSON output", async () => {
+        const mockProc = createMockProcess(0, '{"response": "the answer"}');
+        mockSpawn.mockReturnValue(mockProc);
+        const result = await executeGemini({ prompt: "hello" });
+        expect(result).toBe("the answer");
+    });
+    it("returns raw stdout when JSON has no response field", async () => {
+        const mockProc = createMockProcess(0, '{"other": "data"}');
+        mockSpawn.mockReturnValue(mockProc);
+        const result = await executeGemini({ prompt: "hello" });
+        expect(result).toBe('{"other": "data"}');
+    });
+    it("returns raw stdout when output is not JSON", async () => {
+        const mockProc = createMockProcess(0, "plain text output");
+        mockSpawn.mockReturnValue(mockProc);
+        const result = await executeGemini({ prompt: "hello" });
+        expect(result).toBe("plain text output");
+    });
+    it("rejects on non-zero exit code", async () => {
+        const mockProc = createMockProcess(1, "", "some error");
+        mockSpawn.mockReturnValue(mockProc);
+        expect(executeGemini({ prompt: "hello" })).rejects.toThrow("gemini exited with code 1: some error");
+    });
+    it("rejects on spawn error", async () => {
+        const proc = new EventEmitter();
+        proc.stdin = null;
+        proc.stdout = new EventEmitter();
+        proc.stderr = new EventEmitter();
+        mockSpawn.mockReturnValue(proc);
+        const promise = executeGemini({ prompt: "hello" });
+        setImmediate(() => {
+            proc.emit("error", new Error("ENOENT"));
+        });
+        expect(promise).rejects.toThrow("Failed to spawn gemini: ENOENT");
+    });
+});

package/dist/__tests__/gemini-with-agent-md.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/gemini-with-agent-md.test.js

@@ -0,0 +1,85 @@
+import { describe, it, expect } from "vitest";
+import { readFile } from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
+import { extractModelFromFrontmatter, stripFrontmatter } from "../utils/frontmatter.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const fixturesDir = path.join(__dirname, "fixtures");
+async function loadFixture(name) {
+    return readFile(path.join(fixturesDir, name), "utf-8");
+}
+describe("gemini_with_agent_md with fixtures", () => {
+    describe("model extraction from fixture files", () => {
+        it("extracts haiku model from agent-haiku.md", async () => {
+            const content = await loadFixture("agent-haiku.md");
+            expect(extractModelFromFrontmatter(content)).toBe("gemini-2.5-flash-lite");
+        });
+        it("extracts sonnet model from agent-sonnet.md", async () => {
+            const content = await loadFixture("agent-sonnet.md");
+            expect(extractModelFromFrontmatter(content)).toBe("gemini-2.5-flash");
+        });
+        it("extracts opus model from agent-opus.md", async () => {
+            const content = await loadFixture("agent-opus.md");
+            expect(extractModelFromFrontmatter(content)).toBe("gemini-2.5-pro");
+        });
+        it("returns null for agent-no-model.md", async () => {
+            const content = await loadFixture("agent-no-model.md");
+            expect(extractModelFromFrontmatter(content)).toBeNull();
+        });
+        it("returns null for agent-no-frontmatter.md", async () => {
+            const content = await loadFixture("agent-no-frontmatter.md");
+            expect(extractModelFromFrontmatter(content)).toBeNull();
+        });
+    });
+    describe("frontmatter stripping from fixture files", () => {
+        it("strips frontmatter from agent-haiku.md", async () => {
+            const content = await loadFixture("agent-haiku.md");
+            const stripped = stripFrontmatter(content);
+            expect(stripped).not.toContain("---");
+            expect(stripped).not.toContain("model: haiku");
+            expect(stripped).toContain("# Test Agent (Haiku)");
+        });
+        it("strips frontmatter from agent-no-model.md", async () => {
+            const content = await loadFixture("agent-no-model.md");
+            const stripped = stripFrontmatter(content);
+            expect(stripped).not.toContain("---");
+            expect(stripped).not.toContain("title:");
+            expect(stripped).toContain("# Test Agent (No Model)");
+        });
+        it("preserves content from agent-no-frontmatter.md", async () => {
+            const content = await loadFixture("agent-no-frontmatter.md");
+            const stripped = stripFrontmatter(content);
+            expect(stripped).toBe(content);
+        });
+    });
+    describe("model resolution logic", () => {
+        const DEFAULT_GEMINI_MODEL = "gemini-2.5-flash";
+        function resolveModel(explicitModel, inferredModel) {
+            return explicitModel ?? inferredModel ?? DEFAULT_GEMINI_MODEL;
+        }
+        it("uses explicit model when provided", async () => {
+            const content = await loadFixture("agent-haiku.md");
+            const inferred = extractModelFromFrontmatter(content);
+            const result = resolveModel("gemini-2.5-pro", inferred);
+            expect(result).toBe("gemini-2.5-pro");
+        });
+        it("falls back to inferred model when no explicit model", async () => {
+            const content = await loadFixture("agent-opus.md");
+            const inferred = extractModelFromFrontmatter(content);
+            const result = resolveModel(undefined, inferred);
+            expect(result).toBe("gemini-2.5-pro");
+        });
+        it("falls back to default when no explicit or inferred model", async () => {
+            const content = await loadFixture("agent-no-model.md");
+            const inferred = extractModelFromFrontmatter(content);
+            const result = resolveModel(undefined, inferred);
+            expect(result).toBe(DEFAULT_GEMINI_MODEL);
+        });
+        it("falls back to default for file without frontmatter", async () => {
+            const content = await loadFixture("agent-no-frontmatter.md");
+            const inferred = extractModelFromFrontmatter(content);
+            const result = resolveModel(undefined, inferred);
+            expect(result).toBe(DEFAULT_GEMINI_MODEL);
+        });
+    });
+});

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { GeminiMCPServer } from './server.js';
+const server = new GeminiMCPServer();
+server.run().catch(console.error);

package/dist/server.d.ts

@@ -0,0 +1,6 @@
+export declare class GeminiMCPServer {
+    private readonly server;
+    constructor();
+    private setupTools;
+    run(): Promise<void>;
+}

package/dist/server.js

@@ -0,0 +1,23 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { registerGeminiTool } from "./tools/gemini.js";
+import { registerGeminiWithAgentMdTool } from "./tools/gemini-with-agent-md.js";
+export class GeminiMCPServer {
+    server;
+    constructor() {
+        this.server = new McpServer({
+            name: "gemini-mcp",
+            version: "1.0.0",
+        });
+        this.setupTools();
+    }
+    setupTools() {
+        registerGeminiTool(this.server);
+        registerGeminiWithAgentMdTool(this.server);
+    }
+    async run() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        console.error("Gemini MCP server running on stdio");
+    }
+}

package/dist/tools/gemini-with-agent-md.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare const geminiWithAgentMdInputSchema: {
+    agent_md_path: z.ZodString;
+    prompt: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+    allowed_tools: z.ZodOptional<z.ZodString>;
+};
+export declare function registerGeminiWithAgentMdTool(server: McpServer): void;

package/dist/tools/gemini-with-agent-md.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { readFile } from "fs/promises";
+import { executeGemini, DEFAULT_GEMINI_MODEL } from "../utils/gemini-executor.js";
+import { extractModelFromFrontmatter, stripFrontmatter } from "../utils/frontmatter.js";
+export const geminiWithAgentMdInputSchema = {
+    agent_md_path: z.string().describe("Absolute path to the agent.md file"),
+    prompt: z.string().describe("The prompt to send to Gemini"),
+    model: z
+        .string()
+        .optional()
+        .describe("Gemini model to use. If not specified, infers from agent.md frontmatter (haiku->gemini-2.5-flash-lite, sonnet->gemini-2.5-flash, opus->gemini-2.5-pro). Falls back to gemini-2.5-flash."),
+    allowed_tools: z
+        .string()
+        .optional()
+        .describe('Comma-separated list of tools Gemini can use (e.g., "perplexity_search,shell")'),
+};
+export function registerGeminiWithAgentMdTool(server) {
+    server.registerTool("gemini_with_agent_md", {
+        title: "Gemini CLI with Agent MD",
+        description: "Send a prompt to Gemini CLI with an agent.md file as context. Strips Claude-specific formatting and infers model from frontmatter.",
+        inputSchema: geminiWithAgentMdInputSchema,
+    }, async ({ agent_md_path, prompt, model, allowed_tools }) => {
+        try {
+            const content = await readFile(agent_md_path, "utf-8");
+            const cleaned = stripFrontmatter(content);
+            const inferredModel = extractModelFromFrontmatter(content);
+            const finalModel = model ?? inferredModel ?? DEFAULT_GEMINI_MODEL;
+            console.error(`Piping cleaned agent.md (${cleaned.length} chars), model: ${finalModel}`);
+            const result = await executeGemini({
+                prompt,
+                model: finalModel,
+                allowedTools: allowed_tools,
+                pipeContent: cleaned,
+            });
+            return {
+                content: [{ type: "text", text: result }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error: ${error.message}` }],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/gemini.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare const geminiInputSchema: {
+    prompt: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+    allowed_tools: z.ZodOptional<z.ZodString>;
+};
+export declare function registerGeminiTool(server: McpServer): void;

package/dist/tools/gemini.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { executeGemini, DEFAULT_GEMINI_MODEL } from "../utils/gemini-executor.js";
+export const geminiInputSchema = {
+    prompt: z.string().describe("The prompt to send to Gemini"),
+    model: z
+        .string()
+        .optional()
+        .describe("Gemini model to use (default: gemini-2.5-flash)"),
+    allowed_tools: z
+        .string()
+        .optional()
+        .describe('Comma-separated list of tools Gemini can use (e.g., "perplexity_search,shell")'),
+};
+export function registerGeminiTool(server) {
+    server.registerTool("gemini", {
+        title: "Gemini CLI",
+        description: "Send a prompt to Gemini CLI. Optionally specify model and allowed tools.",
+        inputSchema: geminiInputSchema,
+    }, async ({ prompt, model, allowed_tools }) => {
+        try {
+            const result = await executeGemini({
+                prompt,
+                model: model ?? DEFAULT_GEMINI_MODEL,
+                allowedTools: allowed_tools,
+            });
+            return {
+                content: [{ type: "text", text: result }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error: ${error.message}` }],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/utils/frontmatter.d.ts

@@ -0,0 +1,2 @@
+export declare function extractModelFromFrontmatter(content: string): string | null;
+export declare function stripFrontmatter(content: string): string;

package/dist/utils/frontmatter.js

@@ -0,0 +1,44 @@
+const CLAUDE_TO_GEMINI_MODEL = {
+    haiku: "gemini-2.5-flash-lite",
+    sonnet: "gemini-2.5-flash",
+    opus: "gemini-2.5-pro",
+};
+export function extractModelFromFrontmatter(content) {
+    const lines = content.split("\n");
+    let inFrontmatter = false;
+    for (const line of lines) {
+        if (line.trim() === "---") {
+            if (!inFrontmatter) {
+                inFrontmatter = true;
+                continue;
+            }
+            break;
+        }
+        if (inFrontmatter) {
+            const match = line.match(/^model:\s*(.+)$/);
+            if (match) {
+                const claudeModel = match[1].trim();
+                return CLAUDE_TO_GEMINI_MODEL[claudeModel] ?? null;
+            }
+        }
+    }
+    return null;
+}
+export function stripFrontmatter(content) {
+    const lines = content.split("\n");
+    let inFrontmatter = false;
+    let frontmatterEnd = 0;
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].trim() === "---") {
+            if (!inFrontmatter) {
+                inFrontmatter = true;
+                continue;
+            }
+            else {
+                frontmatterEnd = i + 1;
+                break;
+            }
+        }
+    }
+    return lines.slice(frontmatterEnd).join("\n");
+}

package/dist/utils/gemini-executor.d.ts

@@ -0,0 +1,9 @@
+export declare const DEFAULT_GEMINI_MODEL = "gemini-2.5-flash";
+export declare const DEFAULT_TOOLS: string[];
+export interface ExecuteGeminiOptions {
+    prompt: string;
+    model?: string;
+    allowedTools?: string;
+    pipeContent?: string;
+}
+export declare function executeGemini(options: ExecuteGeminiOptions): Promise<string>;

package/dist/utils/gemini-executor.js

@@ -0,0 +1,45 @@
+import { spawn } from "child_process";
+export const DEFAULT_GEMINI_MODEL = "gemini-2.5-flash";
+export const DEFAULT_TOOLS = ["read_file", "write_file"];
+export async function executeGemini(options) {
+    const { prompt, model = DEFAULT_GEMINI_MODEL, allowedTools, pipeContent } = options;
+    return new Promise((resolve, reject) => {
+        const args = ["-s", "--model", model, "--output-format", "json"];
+        const userTools = allowedTools ? allowedTools.split(",").map(t => t.trim()) : [];
+        const allTools = [...new Set([...DEFAULT_TOOLS, ...userTools])];
+        args.push("--allowed-tools", allTools.join(","));
+        args.push("-p", prompt);
+        console.error(`Executing: gemini ${args.join(" ")}`);
+        const proc = spawn("gemini", args, {
+            stdio: [pipeContent ? "pipe" : "ignore", "pipe", "pipe"],
+        });
+        if (pipeContent && proc.stdin) {
+            proc.stdin.write(pipeContent);
+            proc.stdin.end();
+        }
+        let stdout = "";
+        let stderr = "";
+        proc.stdout?.on("data", (data) => {
+            stdout += data.toString();
+        });
+        proc.stderr?.on("data", (data) => {
+            stderr += data.toString();
+        });
+        proc.on("close", (code) => {
+            if (code !== 0) {
+                reject(new Error(`gemini exited with code ${code}: ${stderr}`));
+                return;
+            }
+            try {
+                const json = JSON.parse(stdout);
+                resolve(json.response ?? stdout);
+            }
+            catch {
+                resolve(stdout);
+            }
+        });
+        proc.on("error", (err) => {
+            reject(new Error(`Failed to spawn gemini: ${err.message}`));
+        });
+    });
+}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@brenoxp/gemini-mcp",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "MCP server that wraps Gemini CLI for use with Claude Code and other MCP clients",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "gemini-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "start": "node dist/index.js",
+    "dev": "npx tsx src/index.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "keywords": [
+    "mcp",
+    "gemini",
+    "claude",
+    "ai",
+    "llm",
+    "model-context-protocol",
+    "claude-code",
+    "gemini-cli"
+  ],
+  "author": "Breno Pinto",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/brenoxp/gemini-mcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/brenoxp/gemini-mcp/issues"
+  },
+  "homepage": "https://github.com/brenoxp/gemini-mcp#readme",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^4.3.5"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^4.0.16"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}