second-opinion-mcp 0.1.0

package/dist/context/bundler.test.js

@@ -0,0 +1,275 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { bundleContext, formatBundleAsMarkdown } from "./bundler.js";
+// Test the sensitive path detection by attempting to include sensitive files
+describe("bundleContext - sensitive path handling", () => {
+    const tmpDir = path.join(os.tmpdir(), "bundler-sensitive-test-" + Date.now());
+    beforeAll(() => {
+        fs.mkdirSync(path.join(tmpDir, "src"), { recursive: true });
+        fs.mkdirSync(path.join(tmpDir, ".ssh"), { recursive: true });
+        fs.mkdirSync(path.join(tmpDir, ".aws"), { recursive: true });
+        // Create normal files
+        fs.writeFileSync(path.join(tmpDir, "src", "index.ts"), "export const main = 1;");
+        // Create sensitive files
+        fs.writeFileSync(path.join(tmpDir, ".ssh", "id_rsa"), "PRIVATE KEY");
+        fs.writeFileSync(path.join(tmpDir, ".aws", "credentials"), "aws_secret=xxx");
+        fs.writeFileSync(path.join(tmpDir, ".env"), "DATABASE_URL=secret");
+        fs.writeFileSync(path.join(tmpDir, "secrets.json"), '{"api_key": "xxx"}');
+    });
+    afterAll(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it("blocks .ssh directory files", async () => {
+        const bundle = await bundleContext({
+            projectPath: tmpDir,
+            includeFiles: [".ssh/id_rsa"],
+            includeConversation: false,
+            includeDependencies: false,
+            includeDependents: false,
+            includeTests: false,
+            includeTypes: false,
+        });
+        expect(bundle.files).toHaveLength(0);
+        expect(bundle.omittedFiles.some((f) => f.reason === "sensitive_path")).toBe(true);
+    });
+    it("blocks .aws directory files", async () => {
+        const bundle = await bundleContext({
+            projectPath: tmpDir,
+            includeFiles: [".aws/credentials"],
+            includeConversation: false,
+            includeDependencies: false,
+            includeDependents: false,
+            includeTests: false,
+            includeTypes: false,
+        });
+        expect(bundle.files).toHaveLength(0);
+        expect(bundle.omittedFiles.some((f) => f.reason === "sensitive_path")).toBe(true);
+    });
+    it("blocks .env files", async () => {
+        const bundle = await bundleContext({
+            projectPath: tmpDir,
+            includeFiles: [".env"],
+            includeConversation: false,
+            includeDependencies: false,
+            includeDependents: false,
+            includeTests: false,
+            includeTypes: false,
+        });
+        expect(bundle.files).toHaveLength(0);
+        expect(bundle.omittedFiles.some((f) => f.reason === "sensitive_path")).toBe(true);
+    });
+    it("blocks secrets.json files", async () => {
+        const bundle = await bundleContext({
+            projectPath: tmpDir,
+            includeFiles: ["secrets.json"],
+            includeConversation: false,
+            includeDependencies: false,
+            includeDependents: false,
+            includeTests: false,
+            includeTypes: false,
+        });
+        expect(bundle.files).toHaveLength(0);
+        expect(bundle.omittedFiles.some((f) => f.reason === "sensitive_path")).toBe(true);
+    });
+    it("allows normal source files", async () => {
+        const bundle = await bundleContext({
+            projectPath: tmpDir,
+            includeFiles: ["src/index.ts"],
+            maxTokens: 10000, // Enough budget for the file
+            includeConversation: false,
+            includeDependencies: false,
+            includeDependents: false,
+            includeTests: false,
+            includeTypes: false,
+        });
+        expect(bundle.files).toHaveLength(1);
+        expect(bundle.files[0].path).toContain("index.ts");
+    });
+});
+describe("bundleContext - external files", () => {
+    const tmpDir = path.join(os.tmpdir(), "bundler-external-test-" + Date.now());
+    const externalDir = path.join(os.tmpdir(), "bundler-external-other-" + Date.now());
+    beforeAll(() => {
+        fs.mkdirSync(path.join(tmpDir, "src"), { recursive: true });
+        fs.mkdirSync(externalDir, { recursive: true });
+        fs.writeFileSync(path.join(tmpDir, "src", "index.ts"), "export const main = 1;");
+        fs.writeFileSync(path.join(externalDir, "external.ts"), "export const ext = 1;");
+    });
+    afterAll(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+        fs.rmSync(externalDir, { recursive: true, force: true });
+    });
+    it("blocks external files by default", async () => {
+        const bundle = await bundleContext({
+            projectPath: tmpDir,
+            includeFiles: [externalDir + "/external.ts"],
+            includeConversation: false,
+            includeDependencies: false,
+            includeDependents: false,
+            includeTests: false,
+            includeTypes: false,
+        });
+        expect(bundle.files).toHaveLength(0);
+        expect(bundle.omittedFiles.some((f) => f.reason === "outside_project_requires_allowExternalFiles")).toBe(true);
+    });
+    it("allows external files when allowExternalFiles is true", async () => {
+        const bundle = await bundleContext({
+            projectPath: tmpDir,
+            includeFiles: [externalDir + "/external.ts"],
+            allowExternalFiles: true,
+            includeConversation: false,
+            includeDependencies: false,
+            includeDependents: false,
+            includeTests: false,
+            includeTypes: false,
+        });
+        expect(bundle.files).toHaveLength(1);
+        expect(bundle.files[0].path).toContain("external.ts");
+    });
+});
+describe("bundleContext - token budget", () => {
+    const tmpDir = path.join(os.tmpdir(), "bundler-budget-test-" + Date.now());
+    beforeAll(() => {
+        fs.mkdirSync(path.join(tmpDir, "src"), { recursive: true });
+        // Create files of known sizes
+        // Budget allocation for explicit files is 15% of maxTokens
+        // With maxTokens=1000, explicit budget = 150 tokens
+        fs.writeFileSync(path.join(tmpDir, "src", "small.ts"), "x".repeat(100)); // ~25 tokens
+        fs.writeFileSync(path.join(tmpDir, "src", "large.ts"), "x".repeat(2000)); // ~500 tokens
+    });
+    afterAll(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it("respects maxTokens budget", async () => {
+        // With maxTokens=1000, explicit budget = 150 tokens
+        // small.ts (~25 tokens) should fit, large.ts (~500 tokens) should not
+        const bundle = await bundleContext({
+            projectPath: tmpDir,
+            includeFiles: ["src/small.ts", "src/large.ts"],
+            maxTokens: 1000,
+            includeConversation: false,
+            includeDependencies: false,
+            includeDependents: false,
+            includeTests: false,
+            includeTypes: false,
+        });
+        // Small file should be included
+        expect(bundle.files.some((f) => f.path.includes("small.ts"))).toBe(true);
+        // Large file should be omitted due to budget
+        expect(bundle.omittedFiles.some((f) => f.reason === "budget_exceeded")).toBe(true);
+        expect(bundle.omittedFiles.some((f) => f.path.includes("large.ts"))).toBe(true);
+    });
+});
+describe("formatBundleAsMarkdown", () => {
+    it("formats bundle with categories", () => {
+        const bundle = {
+            conversationContext: "## Conversation\nUser asked for help",
+            files: [
+                {
+                    path: "/project/src/index.ts",
+                    content: "const x = 1;",
+                    category: "session",
+                    tokenEstimate: 10,
+                },
+                {
+                    path: "/project/src/utils.ts",
+                    content: "export const util = 1;",
+                    category: "dependency",
+                    tokenEstimate: 15,
+                },
+            ],
+            omittedFiles: [],
+            totalTokens: 25,
+            categories: {
+                session: 10,
+                git: 0,
+                dependency: 15,
+                dependent: 0,
+                test: 0,
+                type: 0,
+                explicit: 0,
+            },
+        };
+        const markdown = formatBundleAsMarkdown(bundle, "/project");
+        expect(markdown).toContain("## Conversation");
+        expect(markdown).toContain("Modified Files (from Claude session)");
+        expect(markdown).toContain("Dependencies (files imported by modified code)");
+        expect(markdown).toContain("### src/index.ts");
+        expect(markdown).toContain("### src/utils.ts");
+        expect(markdown).toContain("**Total files:** 2");
+    });
+    it("includes omitted files section when files were omitted", () => {
+        const bundle = {
+            conversationContext: "",
+            files: [],
+            omittedFiles: [
+                {
+                    path: "/project/.env",
+                    category: "explicit",
+                    tokenEstimate: 0,
+                    reason: "sensitive_path",
+                },
+                {
+                    path: "/project/large-file.ts",
+                    category: "session",
+                    tokenEstimate: 50000,
+                    reason: "budget_exceeded",
+                },
+            ],
+            totalTokens: 0,
+            categories: {
+                session: 0,
+                git: 0,
+                dependency: 0,
+                dependent: 0,
+                test: 0,
+                type: 0,
+                explicit: 0,
+            },
+        };
+        const markdown = formatBundleAsMarkdown(bundle, "/project");
+        expect(markdown).toContain("### Omitted Files");
+        expect(markdown).toContain("**Blocked (sensitive path):**");
+        expect(markdown).toContain(".env");
+        expect(markdown).toContain("**Budget exceeded:**");
+        expect(markdown).toContain("large-file.ts");
+    });
+    it("shows context summary with token breakdown", () => {
+        const bundle = {
+            conversationContext: "",
+            files: [
+                {
+                    path: "/project/a.ts",
+                    content: "a",
+                    category: "session",
+                    tokenEstimate: 100,
+                },
+                {
+                    path: "/project/b.ts",
+                    content: "b",
+                    category: "test",
+                    tokenEstimate: 50,
+                },
+            ],
+            omittedFiles: [],
+            totalTokens: 150,
+            categories: {
+                session: 100,
+                git: 0,
+                dependency: 0,
+                dependent: 0,
+                test: 50,
+                type: 0,
+                explicit: 0,
+            },
+        };
+        const markdown = formatBundleAsMarkdown(bundle, "/project");
+        expect(markdown).toContain("## Context Summary");
+        expect(markdown).toContain("**Total files:** 2");
+        expect(markdown).toContain("**Estimated tokens:** 150");
+        expect(markdown).toContain("session: 100 tokens");
+        expect(markdown).toContain("test: 50 tokens");
+    });
+});

package/dist/context/git.d.ts

@@ -0,0 +1,21 @@
+export interface GitChanges {
+    staged: string[];
+    unstaged: string[];
+    untracked: string[];
+}
+/**
+ * Check if a directory is a git repository
+ */
+export declare function isGitRepo(projectPath: string): boolean;
+/**
+ * Get all modified files from git
+ */
+export declare function getGitChanges(projectPath: string): GitChanges;
+/**
+ * Get the diff content for a file
+ */
+export declare function getFileDiff(projectPath: string, filePath: string): string | null;
+/**
+ * Get all modified files (staged + unstaged + untracked) as a single list
+ */
+export declare function getAllModifiedFiles(projectPath: string): string[];

package/dist/context/git.js

@@ -0,0 +1,102 @@
+import { execSync, spawnSync } from "child_process";
+import * as path from "path";
+/**
+ * Check if a directory is a git repository
+ */
+export function isGitRepo(projectPath) {
+    try {
+        execSync("git rev-parse --git-dir", {
+            cwd: projectPath,
+            stdio: "pipe",
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get all modified files from git
+ */
+export function getGitChanges(projectPath) {
+    const changes = {
+        staged: [],
+        unstaged: [],
+        untracked: [],
+    };
+    if (!isGitRepo(projectPath)) {
+        return changes;
+    }
+    try {
+        // Staged changes
+        const staged = execSync("git diff --cached --name-only", {
+            cwd: projectPath,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        changes.staged = staged
+            .split("\n")
+            .filter(Boolean)
+            .map((f) => path.join(projectPath, f));
+        // Unstaged changes
+        const unstaged = execSync("git diff --name-only", {
+            cwd: projectPath,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        changes.unstaged = unstaged
+            .split("\n")
+            .filter(Boolean)
+            .map((f) => path.join(projectPath, f));
+        // Untracked files
+        const untracked = execSync("git ls-files --others --exclude-standard", {
+            cwd: projectPath,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        changes.untracked = untracked
+            .split("\n")
+            .filter(Boolean)
+            .map((f) => path.join(projectPath, f));
+    }
+    catch {
+        // Git commands failed, return empty
+    }
+    return changes;
+}
+/**
+ * Get the diff content for a file
+ */
+export function getFileDiff(projectPath, filePath) {
+    if (!isGitRepo(projectPath)) {
+        return null;
+    }
+    try {
+        const relativePath = path.relative(projectPath, filePath);
+        // Use spawnSync with argument array to prevent command injection
+        const result = spawnSync("git", ["diff", "HEAD", "--", relativePath], {
+            cwd: projectPath,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        if (result.error || result.status !== 0) {
+            return null;
+        }
+        return result.stdout || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get all modified files (staged + unstaged + untracked) as a single list
+ */
+export function getAllModifiedFiles(projectPath) {
+    const changes = getGitChanges(projectPath);
+    const allFiles = new Set([
+        ...changes.staged,
+        ...changes.unstaged,
+        ...changes.untracked,
+    ]);
+    return Array.from(allFiles);
+}

package/dist/context/imports.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Extract import paths from a file's content
+ */
+export declare function extractImports(content: string): string[];
+/**
+ * Check if a path is within the project bounds
+ * Resolves symlinks to handle cases like /var -> /private/var on macOS
+ */
+export declare function isWithinProject(filePath: string, projectPath: string): boolean;
+/**
+ * Resolve an import path to an actual file path
+ */
+export declare function resolveImportPath(importPath: string, fromFile: string, projectPath: string): string | null;
+/**
+ * Get all files that a given file imports (dependencies)
+ */
+export declare function getDependencies(filePath: string, projectPath: string): string[];
+/**
+ * Get dependencies for multiple files
+ */
+export declare function getDependenciesForFiles(files: string[], projectPath: string): string[];
+/**
+ * Import index for efficient dependent lookups
+ * Maps each file to the files that import it (reverse dependency map)
+ */
+export interface ImportIndex {
+    importedBy: Map<string, Set<string>>;
+}
+/**
+ * Build an import index for the project
+ * Scans all files once and builds both forward and reverse dependency maps
+ */
+export declare function buildImportIndex(projectPath: string): Promise<ImportIndex>;
+/**
+ * Get dependents for multiple files using a pre-built index
+ * O(M) lookups instead of O(M*N) file reads
+ */
+export declare function getDependentsFromIndex(files: string[], index: ImportIndex): string[];
+/**
+ * Get dependents for multiple files
+ * Uses an index-based approach for better performance
+ */
+export declare function getDependentsForFiles(files: string[], projectPath: string): Promise<string[]>;

package/dist/context/imports.js

@@ -0,0 +1,197 @@
+import * as fs from "fs";
+import * as path from "path";
+import { glob } from "glob";
+// Regex patterns for different import styles
+const IMPORT_PATTERNS = [
+    // ES6 imports: import x from 'y', import { x } from 'y', import * as x from 'y'
+    /import\s+(?:[\w*{}\s,]+\s+from\s+)?['"]([^'"]+)['"]/g,
+    // ES6 dynamic imports: import('y')
+    /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+    // CommonJS requires: require('y')
+    /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+    // ES6 export from: export { x } from 'y'
+    /export\s+(?:[\w*{}\s,]+\s+)?from\s+['"]([^'"]+)['"]/g,
+];
+// File extensions to consider for imports
+const CODE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+/**
+ * Extract import paths from a file's content
+ */
+export function extractImports(content) {
+    const imports = new Set();
+    for (const pattern of IMPORT_PATTERNS) {
+        // Reset regex state
+        pattern.lastIndex = 0;
+        let match;
+        while ((match = pattern.exec(content)) !== null) {
+            imports.add(match[1]);
+        }
+    }
+    return Array.from(imports);
+}
+/**
+ * Check if a path is within the project bounds
+ * Resolves symlinks to handle cases like /var -> /private/var on macOS
+ */
+export function isWithinProject(filePath, projectPath) {
+    // Use realpathSync to resolve symlinks (falls back to normalize if path doesn't exist)
+    let realFile;
+    let realProject;
+    try {
+        realFile = fs.realpathSync(filePath);
+    }
+    catch {
+        realFile = path.normalize(path.resolve(filePath));
+    }
+    try {
+        realProject = fs.realpathSync(projectPath);
+    }
+    catch {
+        realProject = path.normalize(path.resolve(projectPath));
+    }
+    return realFile.startsWith(realProject + path.sep) ||
+        realFile === realProject;
+}
+/**
+ * Resolve an import path to an actual file path
+ */
+export function resolveImportPath(importPath, fromFile, projectPath) {
+    // Skip node_modules and external packages
+    if (!importPath.startsWith(".") &&
+        !importPath.startsWith("/") &&
+        !importPath.startsWith("@/")) {
+        return null;
+    }
+    const fromDir = path.dirname(fromFile);
+    let targetPath;
+    // Handle @ alias (common in many projects)
+    if (importPath.startsWith("@/")) {
+        targetPath = path.join(projectPath, "src", importPath.slice(2));
+    }
+    else if (importPath.startsWith("/")) {
+        targetPath = path.join(projectPath, importPath);
+    }
+    else {
+        targetPath = path.resolve(fromDir, importPath);
+    }
+    // Try with different extensions
+    const candidates = [
+        targetPath,
+        ...CODE_EXTENSIONS.map((ext) => targetPath + ext),
+        ...CODE_EXTENSIONS.map((ext) => path.join(targetPath, "index" + ext)),
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+            // Bounds check: ensure resolved path is within project
+            if (!isWithinProject(candidate, projectPath)) {
+                return null;
+            }
+            return candidate;
+        }
+    }
+    return null;
+}
+/**
+ * Get all files that a given file imports (dependencies)
+ */
+export function getDependencies(filePath, projectPath) {
+    if (!fs.existsSync(filePath)) {
+        return [];
+    }
+    try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        const importPaths = extractImports(content);
+        const dependencies = [];
+        for (const importPath of importPaths) {
+            const resolved = resolveImportPath(importPath, filePath, projectPath);
+            if (resolved) {
+                dependencies.push(resolved);
+            }
+        }
+        return dependencies;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Get dependencies for multiple files
+ */
+export function getDependenciesForFiles(files, projectPath) {
+    const allDeps = new Set();
+    for (const file of files) {
+        const deps = getDependencies(file, projectPath);
+        for (const dep of deps) {
+            // Don't include files that are already in our modified set
+            if (!files.includes(dep)) {
+                allDeps.add(dep);
+            }
+        }
+    }
+    return Array.from(allDeps);
+}
+/**
+ * Build an import index for the project
+ * Scans all files once and builds both forward and reverse dependency maps
+ */
+export async function buildImportIndex(projectPath) {
+    const index = {
+        importedBy: new Map(),
+    };
+    // Get all code files in the project
+    const patterns = CODE_EXTENSIONS.map((ext) => `**/*${ext}`);
+    const allFiles = await glob(patterns, {
+        cwd: projectPath,
+        absolute: true,
+        ignore: ["**/node_modules/**", "**/dist/**", "**/build/**", "**/.git/**"],
+    });
+    // Build the reverse dependency map by scanning each file once
+    for (const file of allFiles) {
+        try {
+            const content = fs.readFileSync(file, "utf-8");
+            const importPaths = extractImports(content);
+            for (const importPath of importPaths) {
+                const resolved = resolveImportPath(importPath, file, projectPath);
+                if (resolved) {
+                    if (!index.importedBy.has(resolved)) {
+                        index.importedBy.set(resolved, new Set());
+                    }
+                    index.importedBy.get(resolved).add(file);
+                }
+            }
+        }
+        catch {
+            // Skip files that can't be read
+        }
+    }
+    return index;
+}
+/**
+ * Get dependents for multiple files using a pre-built index
+ * O(M) lookups instead of O(M*N) file reads
+ */
+export function getDependentsFromIndex(files, index) {
+    const allDependents = new Set();
+    const fileSet = new Set(files);
+    for (const file of files) {
+        const dependents = index.importedBy.get(file);
+        if (dependents) {
+            for (const dep of dependents) {
+                // Don't include files that are already in our modified set
+                if (!fileSet.has(dep)) {
+                    allDependents.add(dep);
+                }
+            }
+        }
+    }
+    return Array.from(allDependents);
+}
+/**
+ * Get dependents for multiple files
+ * Uses an index-based approach for better performance
+ */
+export async function getDependentsForFiles(files, projectPath) {
+    // Build index once, then do O(1) lookups for each file
+    const index = await buildImportIndex(projectPath);
+    return getDependentsFromIndex(files, index);
+}

package/dist/context/imports.test.d.ts

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