second-opinion-mcp 0.1.0

package/dist/providers/gemini.d.ts

@@ -0,0 +1,8 @@
+import { ReviewProvider, ReviewRequest, ReviewResponse } from "./base.js";
+export declare class GeminiProvider implements ReviewProvider {
+    name: string;
+    private client;
+    private model;
+    constructor(apiKey: string, model?: string);
+    review(request: ReviewRequest): Promise<ReviewResponse>;
+}

package/dist/providers/gemini.js

@@ -0,0 +1,43 @@
+import { GoogleGenerativeAI } from "@google/generative-ai";
+import { buildReviewPrompt, getSystemPrompt, } from "./base.js";
+export class GeminiProvider {
+    name = "gemini";
+    client;
+    model;
+    constructor(apiKey, model = "gemini-2.0-flash-exp") {
+        this.client = new GoogleGenerativeAI(apiKey);
+        this.model = model;
+    }
+    async review(request) {
+        const prompt = buildReviewPrompt(request);
+        const systemInstruction = getSystemPrompt(!!request.task);
+        const model = this.client.getGenerativeModel({
+            model: this.model,
+            systemInstruction,
+        });
+        const result = await model.generateContent({
+            contents: [
+                {
+                    role: "user",
+                    parts: [{ text: prompt }],
+                },
+            ],
+            generationConfig: {
+                maxOutputTokens: 8192,
+                temperature: 0.3, // Lower temperature for more focused reviews
+            },
+        });
+        const response = result.response;
+        const text = response.text();
+        // Get token usage if available
+        const usage = response.usageMetadata;
+        const tokensUsed = usage
+            ? (usage.promptTokenCount || 0) + (usage.candidatesTokenCount || 0)
+            : undefined;
+        return {
+            review: text,
+            model: this.model,
+            tokensUsed,
+        };
+    }
+}

package/dist/providers/index.d.ts

@@ -0,0 +1,8 @@
+import { Config } from "../config.js";
+import { ReviewProvider } from "./base.js";
+export * from "./base.js";
+export * from "./gemini.js";
+export * from "./openai.js";
+export type ProviderName = "gemini" | "openai";
+export declare function createProvider(name: ProviderName, config: Config): ReviewProvider;
+export declare function getAvailableProviders(config: Config): ProviderName[];

package/dist/providers/index.js

@@ -0,0 +1,31 @@
+import { GeminiProvider } from "./gemini.js";
+import { OpenAIProvider } from "./openai.js";
+export * from "./base.js";
+export * from "./gemini.js";
+export * from "./openai.js";
+export function createProvider(name, config) {
+    switch (name) {
+        case "gemini":
+            if (!config.geminiApiKey) {
+                throw new Error("GEMINI_API_KEY is required for Gemini provider");
+            }
+            return new GeminiProvider(config.geminiApiKey, config.geminiModel);
+        case "openai":
+            if (!config.openaiApiKey) {
+                throw new Error("OPENAI_API_KEY is required for OpenAI provider");
+            }
+            return new OpenAIProvider(config.openaiApiKey, config.openaiModel);
+        default:
+            throw new Error(`Unknown provider: ${name}`);
+    }
+}
+export function getAvailableProviders(config) {
+    const providers = [];
+    if (config.geminiApiKey) {
+        providers.push("gemini");
+    }
+    if (config.openaiApiKey) {
+        providers.push("openai");
+    }
+    return providers;
+}

package/dist/providers/openai.d.ts

@@ -0,0 +1,8 @@
+import { ReviewProvider, ReviewRequest, ReviewResponse } from "./base.js";
+export declare class OpenAIProvider implements ReviewProvider {
+    name: string;
+    private client;
+    private model;
+    constructor(apiKey: string, model?: string);
+    review(request: ReviewRequest): Promise<ReviewResponse>;
+}

package/dist/providers/openai.js

@@ -0,0 +1,39 @@
+import OpenAI from "openai";
+import { buildReviewPrompt, getSystemPrompt, } from "./base.js";
+export class OpenAIProvider {
+    name = "openai";
+    client;
+    model;
+    constructor(apiKey, model = "gpt-4o") {
+        this.client = new OpenAI({ apiKey });
+        this.model = model;
+    }
+    async review(request) {
+        const prompt = buildReviewPrompt(request);
+        const systemPrompt = getSystemPrompt(!!request.task);
+        const response = await this.client.chat.completions.create({
+            model: this.model,
+            messages: [
+                {
+                    role: "system",
+                    content: systemPrompt,
+                },
+                {
+                    role: "user",
+                    content: prompt,
+                },
+            ],
+            max_completion_tokens: 8192,
+            temperature: 0.3,
+        });
+        const text = response.choices[0]?.message?.content || "";
+        const tokensUsed = response.usage
+            ? response.usage.prompt_tokens + response.usage.completion_tokens
+            : undefined;
+        return {
+            review: text,
+            model: this.model,
+            tokensUsed,
+        };
+    }
+}

package/dist/server.d.ts

@@ -0,0 +1,3 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+export declare function createServer(): Server;
+export declare function runServer(): Promise<void>;

package/dist/server.js

@@ -0,0 +1,181 @@
+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 { SecondOpinionInputSchema, executeReview, } from "./tools/review.js";
+import { loadConfig } from "./config.js";
+import { getAvailableProviders } from "./providers/index.js";
+export function createServer() {
+    const server = new Server({
+        name: "second-opinion",
+        version: "0.1.0",
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    // List available tools
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        const config = loadConfig();
+        const providers = getAvailableProviders(config);
+        const providerList = providers.length > 0 ? providers.join(", ") : "none configured";
+        return {
+            tools: [
+                {
+                    name: "second_opinion",
+                    description: `Get an async code review from an external LLM. Available providers: ${providerList}.
+
+This tool:
+1. Reads context from your Claude Code session (files read/edited, conversation)
+2. Analyzes dependencies, dependents, tests, and type definitions
+3. Sends the bundled context to Gemini or GPT for review
+4. Writes the review to a markdown file in your project
+
+The reviewer sees the same context Claude had, plus related code for full understanding.`,
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            provider: {
+                                type: "string",
+                                enum: ["gemini", "openai"],
+                                description: "Which LLM to use for the review",
+                            },
+                            projectPath: {
+                                type: "string",
+                                description: "Absolute path to the project being reviewed",
+                            },
+                            sessionId: {
+                                type: "string",
+                                description: "Claude Code session ID (defaults to most recent)",
+                            },
+                            includeConversation: {
+                                type: "boolean",
+                                default: true,
+                                description: "Include conversation context from Claude session",
+                            },
+                            includeDependencies: {
+                                type: "boolean",
+                                default: true,
+                                description: "Include files imported by modified files",
+                            },
+                            includeDependents: {
+                                type: "boolean",
+                                default: true,
+                                description: "Include files that import modified files",
+                            },
+                            includeTests: {
+                                type: "boolean",
+                                default: true,
+                                description: "Include corresponding test files",
+                            },
+                            includeTypes: {
+                                type: "boolean",
+                                default: true,
+                                description: "Include referenced type definitions",
+                            },
+                            maxTokens: {
+                                type: "number",
+                                default: 100000,
+                                description: "Maximum tokens for context",
+                            },
+                            sessionName: {
+                                type: "string",
+                                description: "Name for this review (used in output filename)",
+                            },
+                            customPrompt: {
+                                type: "string",
+                                description: "Additional instructions for the reviewer",
+                            },
+                            focusAreas: {
+                                type: "array",
+                                items: { type: "string" },
+                                description: "Specific areas to focus on",
+                            },
+                            includeFiles: {
+                                type: "array",
+                                items: { type: "string" },
+                                description: "Additional files or folders to include (supports ~ and relative paths)",
+                            },
+                            allowExternalFiles: {
+                                type: "boolean",
+                                default: false,
+                                description: "Allow including files outside the project directory. Required when includeFiles contains paths outside the project.",
+                            },
+                            dryRun: {
+                                type: "boolean",
+                                default: false,
+                                description: "If true, return a preview of what would be sent without calling the external API",
+                            },
+                        },
+                        required: ["provider", "projectPath"],
+                    },
+                },
+            ],
+        };
+    });
+    // Handle tool calls
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        if (request.params.name !== "second_opinion") {
+            throw new Error(`Unknown tool: ${request.params.name}`);
+        }
+        try {
+            // Validate input
+            const input = SecondOpinionInputSchema.parse(request.params.arguments);
+            // Execute the review
+            const result = await executeReview(input);
+            // Handle dry run response
+            if (result.dryRun) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                dryRun: true,
+                                provider: result.provider,
+                                summary: result.summary,
+                                totalTokens: result.totalTokens,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            // Return success response for actual review
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: true,
+                            reviewFile: result.reviewFile,
+                            egressManifestFile: result.egressManifestFile,
+                            provider: result.provider,
+                            model: result.model,
+                            filesReviewed: result.filesReviewed,
+                            contextTokens: result.contextTokens,
+                            tokensUsed: result.tokensUsed,
+                            summary: result.summary,
+                            reviewPreview: result.review.substring(0, 500) + (result.review.length > 500 ? "..." : ""),
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ success: false, error: message }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    return server;
+}
+export async function runServer() {
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}

package/dist/test-utils.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Create a temporary directory for tests
+ */
+export declare function createTempDir(prefix?: string): string;
+/**
+ * Clean up a temporary directory
+ */
+export declare function cleanupTempDir(dir: string): void;
+/**
+ * Create a project structure from a file tree specification
+ *
+ * @example
+ * createProjectStructure(tmpDir, {
+ *   "src/index.ts": "export const main = 1;",
+ *   "src/utils/helper.ts": "export function helper() {}",
+ *   "package.json": '{"name": "test"}'
+ * });
+ */
+export declare function createProjectStructure(baseDir: string, files: Record<string, string>): void;
+/**
+ * Session message for mock session data
+ */
+export interface MockSessionMessage {
+    type: "user" | "assistant";
+    content: string | object;
+    timestamp?: string;
+    toolUses?: MockToolUse[];
+}
+export interface MockToolUse {
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+export interface MockToolResult {
+    tool_use_id: string;
+    content: string;
+}
+/**
+ * Create mock session JSONL data
+ *
+ * @example
+ * const jsonl = createMockSession([
+ *   { type: "user", content: "Help me with this code" },
+ *   { type: "assistant", content: "I'll help you.", toolUses: [...] }
+ * ]);
+ */
+export declare function createMockSession(messages: MockSessionMessage[]): string;
+/**
+ * Create a mock tool result entry
+ */
+export declare function createMockToolResult(toolUseId: string, content: string): string;
+/**
+ * Create a sessions-index.json file
+ */
+export interface MockSessionIndexEntry {
+    sessionId: string;
+    firstPrompt?: string;
+    projectPath?: string;
+    modified?: string;
+}
+export declare function createMockSessionIndex(projectDir: string, entries: MockSessionIndexEntry[], originalPath?: string): void;
+/**
+ * Initialize a git repo in a directory (for git tests)
+ * Uses execSync with static arguments - safe for test utilities
+ */
+export declare function initGitRepo(dir: string): void;
+/**
+ * Make a git commit in a directory
+ * Uses execSync with static arguments - safe for test utilities
+ */
+export declare function gitCommit(dir: string, message?: string): void;

package/dist/test-utils.js

@@ -0,0 +1,136 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { execSync } from "child_process";
+/**
+ * Create a temporary directory for tests
+ */
+export function createTempDir(prefix = "test") {
+    const dir = path.join(os.tmpdir(), `second-opinion-${prefix}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    fs.mkdirSync(dir, { recursive: true });
+    return dir;
+}
+/**
+ * Clean up a temporary directory
+ */
+export function cleanupTempDir(dir) {
+    if (dir.startsWith(os.tmpdir())) {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+}
+/**
+ * Create a project structure from a file tree specification
+ *
+ * @example
+ * createProjectStructure(tmpDir, {
+ *   "src/index.ts": "export const main = 1;",
+ *   "src/utils/helper.ts": "export function helper() {}",
+ *   "package.json": '{"name": "test"}'
+ * });
+ */
+export function createProjectStructure(baseDir, files) {
+    for (const [relativePath, content] of Object.entries(files)) {
+        const fullPath = path.join(baseDir, relativePath);
+        const dir = path.dirname(fullPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(fullPath, content, "utf-8");
+    }
+}
+/**
+ * Create mock session JSONL data
+ *
+ * @example
+ * const jsonl = createMockSession([
+ *   { type: "user", content: "Help me with this code" },
+ *   { type: "assistant", content: "I'll help you.", toolUses: [...] }
+ * ]);
+ */
+export function createMockSession(messages) {
+    const lines = [];
+    const baseTime = Date.now();
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        const timestamp = msg.timestamp || new Date(baseTime + i * 1000).toISOString();
+        if (msg.type === "user") {
+            const entry = {
+                type: "user",
+                message: {
+                    content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+                },
+                timestamp,
+            };
+            lines.push(JSON.stringify(entry));
+        }
+        else {
+            const contentBlocks = [];
+            // Add text content if it's a string
+            if (typeof msg.content === "string" && msg.content.length > 0) {
+                contentBlocks.push({ type: "text", text: msg.content });
+            }
+            // Add tool uses if present
+            if (msg.toolUses) {
+                for (const toolUse of msg.toolUses) {
+                    contentBlocks.push({
+                        type: "tool_use",
+                        id: toolUse.id,
+                        name: toolUse.name,
+                        input: toolUse.input,
+                    });
+                }
+            }
+            const entry = {
+                type: "assistant",
+                message: {
+                    content: contentBlocks,
+                },
+                timestamp,
+            };
+            lines.push(JSON.stringify(entry));
+        }
+    }
+    return lines.join("\n");
+}
+/**
+ * Create a mock tool result entry
+ */
+export function createMockToolResult(toolUseId, content) {
+    const entry = {
+        type: "tool_result",
+        tool_use_id: toolUseId,
+        content,
+    };
+    return JSON.stringify(entry);
+}
+export function createMockSessionIndex(projectDir, entries, originalPath) {
+    const index = {
+        entries: entries.map((e) => ({
+            sessionId: e.sessionId,
+            fullPath: path.join(projectDir, `${e.sessionId}.jsonl`),
+            firstPrompt: e.firstPrompt || "Test prompt",
+            projectPath: e.projectPath,
+            modified: e.modified || new Date().toISOString(),
+        })),
+        originalPath,
+    };
+    fs.writeFileSync(path.join(projectDir, "sessions-index.json"), JSON.stringify(index, null, 2));
+}
+/**
+ * Initialize a git repo in a directory (for git tests)
+ * Uses execSync with static arguments - safe for test utilities
+ */
+export function initGitRepo(dir) {
+    execSync("git init", { cwd: dir, stdio: "pipe" });
+    execSync("git config user.email 'test@test.com'", { cwd: dir, stdio: "pipe" });
+    execSync("git config user.name 'Test'", { cwd: dir, stdio: "pipe" });
+}
+/**
+ * Make a git commit in a directory
+ * Uses execSync with static arguments - safe for test utilities
+ */
+export function gitCommit(dir, message = "Initial commit") {
+    execSync("git add -A", { cwd: dir, stdio: "pipe" });
+    // Use array-based command to safely handle the message
+    execSync(`git commit -m "${message.replace(/"/g, '\\"')}" --allow-empty`, { cwd: dir, stdio: "pipe" });
+}

package/dist/tools/review.d.ts

@@ -0,0 +1,76 @@
+import { z } from "zod";
+import { EgressSummary } from "../output/writer.js";
+export declare const SecondOpinionInputSchema: z.ZodObject<{
+    provider: z.ZodEnum<["gemini", "openai"]>;
+    projectPath: z.ZodString;
+    task: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    includeFiles: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    allowExternalFiles: z.ZodDefault<z.ZodBoolean>;
+    includeConversation: z.ZodDefault<z.ZodBoolean>;
+    includeDependencies: z.ZodDefault<z.ZodBoolean>;
+    includeDependents: z.ZodDefault<z.ZodBoolean>;
+    includeTests: z.ZodDefault<z.ZodBoolean>;
+    includeTypes: z.ZodDefault<z.ZodBoolean>;
+    maxTokens: z.ZodDefault<z.ZodNumber>;
+    sessionName: z.ZodOptional<z.ZodString>;
+    customPrompt: z.ZodOptional<z.ZodString>;
+    focusAreas: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    dryRun: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    allowExternalFiles: boolean;
+    projectPath: string;
+    includeConversation: boolean;
+    includeDependencies: boolean;
+    includeDependents: boolean;
+    includeTests: boolean;
+    includeTypes: boolean;
+    maxTokens: number;
+    provider: "gemini" | "openai";
+    dryRun: boolean;
+    sessionId?: string | undefined;
+    includeFiles?: string[] | undefined;
+    task?: string | undefined;
+    sessionName?: string | undefined;
+    customPrompt?: string | undefined;
+    focusAreas?: string[] | undefined;
+}, {
+    projectPath: string;
+    provider: "gemini" | "openai";
+    allowExternalFiles?: boolean | undefined;
+    sessionId?: string | undefined;
+    includeConversation?: boolean | undefined;
+    includeDependencies?: boolean | undefined;
+    includeDependents?: boolean | undefined;
+    includeTests?: boolean | undefined;
+    includeTypes?: boolean | undefined;
+    includeFiles?: string[] | undefined;
+    maxTokens?: number | undefined;
+    task?: string | undefined;
+    sessionName?: string | undefined;
+    customPrompt?: string | undefined;
+    focusAreas?: string[] | undefined;
+    dryRun?: boolean | undefined;
+}>;
+export type SecondOpinionInput = z.infer<typeof SecondOpinionInputSchema>;
+export type { EgressSummary } from "../output/writer.js";
+export interface SecondOpinionDryRunOutput {
+    dryRun: true;
+    provider: string;
+    summary: EgressSummary;
+    totalTokens: number;
+}
+export interface SecondOpinionOutput {
+    dryRun?: false;
+    review: string;
+    reviewFile: string;
+    egressManifestFile: string;
+    provider: string;
+    model: string;
+    tokensUsed?: number;
+    timestamp: string;
+    filesReviewed: number;
+    contextTokens: number;
+    summary: EgressSummary;
+}
+export declare function executeReview(input: SecondOpinionInput): Promise<SecondOpinionOutput | SecondOpinionDryRunOutput>;