second-opinion-mcp 0.1.0

package/dist/context/imports.test.js

@@ -0,0 +1,147 @@
+import { describe, it, expect } from "vitest";
+import { extractImports, isWithinProject, resolveImportPath, getDependencies, getDependenciesForFiles, } from "./imports.js";
+import * as path from "path";
+import * as fs from "fs";
+import * as os from "os";
+describe("extractImports", () => {
+    it("extracts ES6 default imports", () => {
+        const code = `import foo from './foo';`;
+        expect(extractImports(code)).toContain("./foo");
+    });
+    it("extracts ES6 named imports", () => {
+        const code = `import { bar, baz } from './utils';`;
+        expect(extractImports(code)).toContain("./utils");
+    });
+    it("extracts ES6 namespace imports", () => {
+        const code = `import * as helpers from './helpers';`;
+        expect(extractImports(code)).toContain("./helpers");
+    });
+    it("extracts dynamic imports", () => {
+        const code = `const module = await import('./dynamic');`;
+        expect(extractImports(code)).toContain("./dynamic");
+    });
+    it("extracts CommonJS requires", () => {
+        const code = `const fs = require('fs');`;
+        expect(extractImports(code)).toContain("fs");
+    });
+    it("extracts export from statements", () => {
+        const code = `export { foo } from './foo';`;
+        expect(extractImports(code)).toContain("./foo");
+    });
+    it("extracts multiple imports from same file", () => {
+        const code = `
+      import foo from './foo';
+      import { bar } from './bar';
+      const baz = require('./baz');
+    `;
+        const imports = extractImports(code);
+        expect(imports).toContain("./foo");
+        expect(imports).toContain("./bar");
+        expect(imports).toContain("./baz");
+    });
+    it("deduplicates imports", () => {
+        const code = `
+      import foo from './foo';
+      import { bar } from './foo';
+    `;
+        const imports = extractImports(code);
+        expect(imports.filter((i) => i === "./foo")).toHaveLength(1);
+    });
+});
+describe("isWithinProject", () => {
+    it("returns true for files inside project", () => {
+        expect(isWithinProject("/project/src/file.ts", "/project")).toBe(true);
+    });
+    it("returns true for project root itself", () => {
+        expect(isWithinProject("/project", "/project")).toBe(true);
+    });
+    it("returns false for files outside project", () => {
+        expect(isWithinProject("/other/file.ts", "/project")).toBe(false);
+    });
+    it("returns false for sibling directories with similar names", () => {
+        expect(isWithinProject("/project-other/file.ts", "/project")).toBe(false);
+    });
+    it("handles path traversal attempts", () => {
+        expect(isWithinProject("/project/../other/file.ts", "/project")).toBe(false);
+    });
+});
+describe("resolveImportPath", () => {
+    // These tests need a temp directory with actual files
+    const tmpDir = path.join(os.tmpdir(), "imports-test-" + Date.now());
+    // Create test files before tests
+    beforeAll(() => {
+        fs.mkdirSync(path.join(tmpDir, "src"), { recursive: true });
+        fs.writeFileSync(path.join(tmpDir, "src", "foo.ts"), "export const foo = 1;");
+        fs.writeFileSync(path.join(tmpDir, "src", "index.ts"), "export * from './foo';");
+        fs.mkdirSync(path.join(tmpDir, "src", "utils"), { recursive: true });
+        fs.writeFileSync(path.join(tmpDir, "src", "utils", "index.ts"), "export const util = 1;");
+    });
+    afterAll(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it("resolves relative imports", () => {
+        const result = resolveImportPath("./foo", path.join(tmpDir, "src", "index.ts"), tmpDir);
+        expect(result).toBe(path.join(tmpDir, "src", "foo.ts"));
+    });
+    it("resolves directory imports to index file", () => {
+        const result = resolveImportPath("./utils", path.join(tmpDir, "src", "index.ts"), tmpDir);
+        expect(result).toBe(path.join(tmpDir, "src", "utils", "index.ts"));
+    });
+    it("returns null for node_modules imports", () => {
+        const result = resolveImportPath("lodash", path.join(tmpDir, "src", "index.ts"), tmpDir);
+        expect(result).toBeNull();
+    });
+    it("returns null for non-existent files", () => {
+        const result = resolveImportPath("./nonexistent", path.join(tmpDir, "src", "index.ts"), tmpDir);
+        expect(result).toBeNull();
+    });
+});
+describe("getDependencies", () => {
+    const tmpDir = path.join(os.tmpdir(), "deps-test-" + Date.now());
+    beforeAll(() => {
+        fs.mkdirSync(path.join(tmpDir, "src"), { recursive: true });
+        fs.writeFileSync(path.join(tmpDir, "src", "main.ts"), `import { foo } from './foo';\nimport { bar } from './bar';`);
+        fs.writeFileSync(path.join(tmpDir, "src", "foo.ts"), "export const foo = 1;");
+        fs.writeFileSync(path.join(tmpDir, "src", "bar.ts"), "export const bar = 2;");
+    });
+    afterAll(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it("returns all resolved dependencies", () => {
+        const deps = getDependencies(path.join(tmpDir, "src", "main.ts"), tmpDir);
+        expect(deps).toContain(path.join(tmpDir, "src", "foo.ts"));
+        expect(deps).toContain(path.join(tmpDir, "src", "bar.ts"));
+    });
+    it("returns empty array for non-existent file", () => {
+        const deps = getDependencies(path.join(tmpDir, "nonexistent.ts"), tmpDir);
+        expect(deps).toEqual([]);
+    });
+});
+describe("getDependenciesForFiles", () => {
+    const tmpDir = path.join(os.tmpdir(), "multi-deps-test-" + Date.now());
+    beforeAll(() => {
+        fs.mkdirSync(path.join(tmpDir, "src"), { recursive: true });
+        fs.writeFileSync(path.join(tmpDir, "src", "a.ts"), `import { shared } from './shared';`);
+        fs.writeFileSync(path.join(tmpDir, "src", "b.ts"), `import { shared } from './shared';`);
+        fs.writeFileSync(path.join(tmpDir, "src", "shared.ts"), "export const shared = 1;");
+    });
+    afterAll(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it("collects dependencies from multiple files", () => {
+        const deps = getDependenciesForFiles([path.join(tmpDir, "src", "a.ts"), path.join(tmpDir, "src", "b.ts")], tmpDir);
+        expect(deps).toContain(path.join(tmpDir, "src", "shared.ts"));
+    });
+    it("excludes files already in the input list", () => {
+        const deps = getDependenciesForFiles([
+            path.join(tmpDir, "src", "a.ts"),
+            path.join(tmpDir, "src", "shared.ts"),
+        ], tmpDir);
+        expect(deps).not.toContain(path.join(tmpDir, "src", "shared.ts"));
+    });
+    it("deduplicates dependencies", () => {
+        const deps = getDependenciesForFiles([path.join(tmpDir, "src", "a.ts"), path.join(tmpDir, "src", "b.ts")], tmpDir);
+        const sharedCount = deps.filter((d) => d.endsWith("shared.ts")).length;
+        expect(sharedCount).toBe(1);
+    });
+});

package/dist/context/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./session.js";
+export * from "./git.js";
+export * from "./imports.js";
+export * from "./tests.js";
+export * from "./types.js";
+export * from "./bundler.js";

package/dist/context/index.js

@@ -0,0 +1,6 @@
+export * from "./session.js";
+export * from "./git.js";
+export * from "./imports.js";
+export * from "./tests.js";
+export * from "./types.js";
+export * from "./bundler.js";

package/dist/context/session.d.ts

@@ -0,0 +1,35 @@
+export interface SessionMessage {
+    role: "user" | "assistant";
+    content: string;
+    timestamp: string;
+}
+export interface FileOperation {
+    type: "read" | "write" | "edit";
+    filePath: string;
+    content?: string;
+}
+export interface SessionContext {
+    sessionId: string;
+    projectPath: string;
+    filesRead: string[];
+    filesWritten: string[];
+    filesEdited: string[];
+    fileContents: Map<string, string>;
+    conversation: SessionMessage[];
+}
+/**
+ * Find the most recent session for a project
+ */
+export declare function findLatestSession(projectPath: string): string | null;
+/**
+ * Get the path to a session's JSONL file
+ */
+export declare function getSessionPath(projectPath: string, sessionId: string): string | null;
+/**
+ * Parse a session JSONL file and extract context
+ */
+export declare function parseSession(projectPath: string, sessionId: string): SessionContext | null;
+/**
+ * Format session context as markdown for the reviewer
+ */
+export declare function formatConversationContext(context: SessionContext): string;

package/dist/context/session.js

@@ -0,0 +1,317 @@
+import * as fs from "fs";
+import * as path from "path";
+import { getClaudeProjectsDir } from "../config.js";
+/**
+ * Convert a project path to the Claude projects directory name format
+ * e.g., /Users/noel/w/my-project -> -Users-noel-w-my-project
+ */
+function projectPathToDir(projectPath) {
+    return projectPath.replace(/\//g, "-");
+}
+/**
+ * Resolve persisted content from tool results
+ * When tool output is too large, Claude Code saves it to a file and includes a marker
+ */
+function resolvePersistedContent(content, projectDir) {
+    // Check for the persisted-output marker
+    const persistedMatch = content.match(/<persisted-output>[\s\S]*?Full output saved to:\s*([^\s<]+)/);
+    if (!persistedMatch) {
+        return content;
+    }
+    const savedPath = persistedMatch[1];
+    // Try reading the full content from the saved file
+    // The path might be relative to the project dir or absolute
+    const candidates = [
+        savedPath,
+        path.join(projectDir, savedPath),
+        path.join(projectDir, "tool-results", path.basename(savedPath)),
+    ];
+    for (const candidate of candidates) {
+        try {
+            if (fs.existsSync(candidate)) {
+                return fs.readFileSync(candidate, "utf-8");
+            }
+        }
+        catch {
+            // Continue to next candidate
+        }
+    }
+    // Couldn't find the persisted file, return original content
+    return content;
+}
+/**
+ * Find the project directory by scanning all sessions-index.json files
+ * and matching by originalPath or projectPath fields
+ */
+function findProjectDir(projectPath) {
+    const projectsDir = getClaudeProjectsDir();
+    // Normalize the project path for comparison
+    const normalizedProjectPath = path.normalize(projectPath);
+    // First, try the direct mapping (fallback)
+    const directDir = path.join(projectsDir, projectPathToDir(projectPath));
+    if (fs.existsSync(path.join(directDir, "sessions-index.json"))) {
+        return directDir;
+    }
+    // Scan all subdirectories in the projects dir
+    try {
+        const entries = fs.readdirSync(projectsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const indexPath = path.join(projectsDir, entry.name, "sessions-index.json");
+            if (!fs.existsSync(indexPath))
+                continue;
+            try {
+                const index = JSON.parse(fs.readFileSync(indexPath, "utf-8"));
+                // Check originalPath field
+                if (index.originalPath) {
+                    const normalizedOriginal = path.normalize(index.originalPath);
+                    if (normalizedOriginal === normalizedProjectPath) {
+                        return path.join(projectsDir, entry.name);
+                    }
+                }
+                // Check projectPath in entries
+                for (const session of index.entries) {
+                    if (session.projectPath) {
+                        const normalizedEntry = path.normalize(session.projectPath);
+                        if (normalizedEntry === normalizedProjectPath) {
+                            return path.join(projectsDir, entry.name);
+                        }
+                    }
+                }
+            }
+            catch {
+                // Skip malformed index files
+            }
+        }
+    }
+    catch {
+        // If we can't read the projects dir, fall back to direct mapping
+    }
+    return null;
+}
+/**
+ * Find the most recent session for a project
+ */
+export function findLatestSession(projectPath) {
+    const projectDir = findProjectDir(projectPath);
+    if (!projectDir) {
+        return null;
+    }
+    const indexPath = path.join(projectDir, "sessions-index.json");
+    if (!fs.existsSync(indexPath)) {
+        return null;
+    }
+    try {
+        const index = JSON.parse(fs.readFileSync(indexPath, "utf-8"));
+        if (index.entries.length === 0) {
+            return null;
+        }
+        // Sort by modified date, most recent first
+        const sorted = [...index.entries].sort((a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime());
+        return sorted[0].sessionId;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get the path to a session's JSONL file
+ */
+export function getSessionPath(projectPath, sessionId) {
+    const projectDir = findProjectDir(projectPath);
+    if (!projectDir) {
+        return null;
+    }
+    const sessionPath = path.join(projectDir, `${sessionId}.jsonl`);
+    if (fs.existsSync(sessionPath)) {
+        return sessionPath;
+    }
+    return null;
+}
+/**
+ * Parse a session JSONL file and extract context
+ */
+export function parseSession(projectPath, sessionId) {
+    const sessionPath = getSessionPath(projectPath, sessionId);
+    if (!sessionPath) {
+        return null;
+    }
+    // Get the project directory for resolving persisted content
+    const projectDir = path.dirname(sessionPath);
+    const context = {
+        sessionId,
+        projectPath,
+        filesRead: [],
+        filesWritten: [],
+        filesEdited: [],
+        fileContents: new Map(),
+        conversation: [],
+    };
+    const fileReadSet = new Set();
+    const fileWrittenSet = new Set();
+    const fileEditedSet = new Set();
+    // Track tool_use IDs to match with results
+    const pendingToolUses = new Map();
+    const lines = fs.readFileSync(sessionPath, "utf-8").split("\n");
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        try {
+            const entry = JSON.parse(line);
+            // Extract user messages
+            if (entry.type === "user" && entry.message?.content) {
+                const content = typeof entry.message.content === "string"
+                    ? entry.message.content
+                    : JSON.stringify(entry.message.content);
+                // Skip system/meta messages
+                if (!content.startsWith("<local-command") &&
+                    !content.startsWith("<command-")) {
+                    context.conversation.push({
+                        role: "user",
+                        content: content,
+                        timestamp: entry.timestamp,
+                    });
+                }
+            }
+            // Extract assistant messages
+            if (entry.type === "assistant" && entry.message?.content) {
+                const contents = Array.isArray(entry.message.content)
+                    ? entry.message.content
+                    : [entry.message.content];
+                for (const block of contents) {
+                    // Text responses
+                    if (block.type === "text" && block.text) {
+                        // Skip API errors
+                        if (!block.text.startsWith("API Error:")) {
+                            context.conversation.push({
+                                role: "assistant",
+                                content: block.text,
+                                timestamp: entry.timestamp,
+                            });
+                        }
+                    }
+                    // Tool uses - track file operations
+                    if (block.type === "tool_use") {
+                        const toolName = block.name;
+                        const input = block.input || {};
+                        const toolId = block.id;
+                        if (toolName === "Read" && input.file_path) {
+                            fileReadSet.add(input.file_path);
+                            pendingToolUses.set(toolId, {
+                                type: "read",
+                                filePath: input.file_path,
+                            });
+                        }
+                        else if (toolName === "Write" && input.file_path) {
+                            fileWrittenSet.add(input.file_path);
+                            if (input.content) {
+                                context.fileContents.set(input.file_path, input.content);
+                            }
+                        }
+                        else if (toolName === "Edit" && input.file_path) {
+                            fileEditedSet.add(input.file_path);
+                        }
+                    }
+                    // Tool results - capture file contents from Read operations
+                    if (block.type === "tool_result" && block.tool_use_id) {
+                        const pending = pendingToolUses.get(block.tool_use_id);
+                        if (pending && pending.type === "read" && block.content) {
+                            // Resolve persisted content if the result was saved to a file
+                            const resolvedContent = resolvePersistedContent(block.content, projectDir);
+                            // Store the content Claude saw
+                            context.fileContents.set(pending.filePath, resolvedContent);
+                            pendingToolUses.delete(block.tool_use_id);
+                        }
+                    }
+                }
+            }
+            // Also check for tool_result in the message content directly
+            if (entry.message?.content) {
+                const contents = Array.isArray(entry.message.content)
+                    ? entry.message.content
+                    : [];
+                for (const block of contents) {
+                    if (block.type === "tool_result" && block.tool_use_id) {
+                        const pending = pendingToolUses.get(block.tool_use_id);
+                        if (pending && pending.type === "read" && block.content) {
+                            // Resolve persisted content if the result was saved to a file
+                            const resolvedContent = resolvePersistedContent(block.content, projectDir);
+                            context.fileContents.set(pending.filePath, resolvedContent);
+                            pendingToolUses.delete(block.tool_use_id);
+                        }
+                    }
+                }
+            }
+            // Handle top-level tool_result entries (some Claude Code versions use this format)
+            if (entry.type === "tool_result" && entry.tool_use_id) {
+                const pending = pendingToolUses.get(entry.tool_use_id);
+                if (pending && pending.type === "read" && entry.content) {
+                    const content = typeof entry.content === "string"
+                        ? entry.content
+                        : JSON.stringify(entry.content);
+                    const resolvedContent = resolvePersistedContent(content, projectDir);
+                    context.fileContents.set(pending.filePath, resolvedContent);
+                    pendingToolUses.delete(entry.tool_use_id);
+                }
+            }
+        }
+        catch {
+            // Skip malformed lines
+        }
+    }
+    context.filesRead = Array.from(fileReadSet);
+    context.filesWritten = Array.from(fileWrittenSet);
+    context.filesEdited = Array.from(fileEditedSet);
+    return context;
+}
+/**
+ * Remove or condense code blocks from a message to avoid stale code in conversation
+ * The Files section contains current code, so we don't need it duplicated here
+ */
+function condenseCodeBlocks(content) {
+    // Match fenced code blocks (```...```)
+    const codeBlockRegex = /```[\s\S]*?```/g;
+    // Count code blocks and their total size
+    const codeBlocks = content.match(codeBlockRegex) || [];
+    const codeSize = codeBlocks.reduce((sum, block) => sum + block.length, 0);
+    // If more than 50% of the message is code, it's primarily a code dump
+    if (codeSize > content.length * 0.5 && codeSize > 500) {
+        // Replace code blocks with placeholder
+        return content.replace(codeBlockRegex, "\n[code snippet omitted - see Files section for current code]\n");
+    }
+    // For smaller code blocks, keep them but truncate if very long
+    return content.replace(codeBlockRegex, (block) => {
+        if (block.length > 500) {
+            const lines = block.split("\n");
+            const lang = lines[0]; // ```language
+            const preview = lines.slice(1, 6).join("\n"); // First few lines
+            return `${lang}\n${preview}\n... [truncated - see Files section]\n\`\`\``;
+        }
+        return block;
+    });
+}
+/**
+ * Format session context as markdown for the reviewer
+ */
+export function formatConversationContext(context) {
+    if (context.conversation.length === 0) {
+        return "";
+    }
+    let output = "## Conversation Context\n\n";
+    output +=
+        "This is the conversation between the user and Claude that led to these changes.\n";
+    output +=
+        "*Note: Code snippets in conversation may be outdated. See the Files section for current code.*\n\n";
+    for (const msg of context.conversation) {
+        const role = msg.role === "user" ? "**User**" : "**Claude**";
+        // Condense code blocks to avoid stale code confusion
+        let content = condenseCodeBlocks(msg.content);
+        // Truncate very long messages
+        if (content.length > 2000) {
+            content = content.substring(0, 2000) + "\n...(truncated)";
+        }
+        output += `${role}:\n${content}\n\n`;
+    }
+    return output;
+}

package/dist/context/tests.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Find test files that correspond to a given source file
+ *
+ * Checks common test file patterns:
+ * - foo.ts -> foo.test.ts, foo.spec.ts
+ * - foo.ts -> __tests__/foo.ts, __tests__/foo.test.ts
+ * - src/foo.ts -> tests/foo.test.ts, test/foo.test.ts
+ */
+export declare function findTestFiles(filePath: string, projectPath: string): string[];
+/**
+ * Find test files for multiple source files
+ */
+export declare function findTestFilesForFiles(files: string[], projectPath: string): string[];

package/dist/context/tests.js

@@ -0,0 +1,83 @@
+import * as fs from "fs";
+import * as path from "path";
+/**
+ * Find test files that correspond to a given source file
+ *
+ * Checks common test file patterns:
+ * - foo.ts -> foo.test.ts, foo.spec.ts
+ * - foo.ts -> __tests__/foo.ts, __tests__/foo.test.ts
+ * - src/foo.ts -> tests/foo.test.ts, test/foo.test.ts
+ */
+export function findTestFiles(filePath, projectPath) {
+    const testFiles = [];
+    const ext = path.extname(filePath);
+    const baseName = path.basename(filePath, ext);
+    const dir = path.dirname(filePath);
+    const relativeDir = path.relative(projectPath, dir);
+    // Common test extensions
+    const testExtensions = [".test" + ext, ".spec" + ext, ext];
+    // Pattern 1: Same directory - foo.test.ts, foo.spec.ts
+    for (const testExt of [".test" + ext, ".spec" + ext]) {
+        const candidate = path.join(dir, baseName + testExt);
+        if (fs.existsSync(candidate)) {
+            testFiles.push(candidate);
+        }
+    }
+    // Pattern 2: __tests__ directory in same location
+    const testsDir = path.join(dir, "__tests__");
+    if (fs.existsSync(testsDir)) {
+        for (const testExt of testExtensions) {
+            const candidate = path.join(testsDir, baseName + testExt);
+            if (fs.existsSync(candidate)) {
+                testFiles.push(candidate);
+            }
+        }
+    }
+    // Pattern 3: Top-level tests/ or test/ directory mirroring src structure
+    const testRootDirs = ["tests", "test", "__tests__"];
+    for (const testRoot of testRootDirs) {
+        const testRootPath = path.join(projectPath, testRoot);
+        if (fs.existsSync(testRootPath)) {
+            // Try to mirror the relative path
+            // e.g., src/auth/login.ts -> tests/auth/login.test.ts
+            let mirrorPath = relativeDir;
+            if (mirrorPath.startsWith("src/") || mirrorPath.startsWith("src\\")) {
+                mirrorPath = mirrorPath.slice(4);
+            }
+            const mirrorDir = path.join(testRootPath, mirrorPath);
+            if (fs.existsSync(mirrorDir)) {
+                for (const testExt of testExtensions) {
+                    const candidate = path.join(mirrorDir, baseName + testExt);
+                    if (fs.existsSync(candidate)) {
+                        testFiles.push(candidate);
+                    }
+                }
+            }
+            // Also try without mirroring - just tests/foo.test.ts
+            for (const testExt of testExtensions) {
+                const candidate = path.join(testRootPath, baseName + testExt);
+                if (fs.existsSync(candidate)) {
+                    testFiles.push(candidate);
+                }
+            }
+        }
+    }
+    // Deduplicate
+    return [...new Set(testFiles)];
+}
+/**
+ * Find test files for multiple source files
+ */
+export function findTestFilesForFiles(files, projectPath) {
+    const allTests = new Set();
+    for (const file of files) {
+        const tests = findTestFiles(file, projectPath);
+        for (const test of tests) {
+            // Don't include if it's already in our file list
+            if (!files.includes(test)) {
+                allTests.add(test);
+            }
+        }
+    }
+    return Array.from(allTests);
+}

package/dist/context/types.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Extract type-related imports from file content
+ */
+export declare function extractTypeImports(content: string): string[];
+/**
+ * Check if a file path looks like a type definition file
+ */
+export declare function isTypeFile(filePath: string): boolean;
+/**
+ * Find all type definition files in a project
+ */
+export declare function findAllTypeFiles(projectPath: string): Promise<string[]>;
+/**
+ * Find type files that are imported by the given files
+ */
+export declare function findTypeFilesForFiles(files: string[], projectPath: string): Promise<string[]>;