second-opinion-mcp 0.1.0

package/dist/context/types.js

@@ -0,0 +1,100 @@
+import * as fs from "fs";
+import { glob } from "glob";
+import { resolveImportPath } from "./imports.js";
+// Patterns for type imports
+const TYPE_IMPORT_PATTERNS = [
+    // import type { X } from 'y'
+    /import\s+type\s+\{[^}]+\}\s+from\s+['"]([^'"]+)['"]/g,
+    // import { type X } from 'y'
+    /import\s+\{[^}]*type\s+\w+[^}]*\}\s+from\s+['"]([^'"]+)['"]/g,
+    // Regular imports from type-ish locations
+    /import\s+(?:[\w*{}\s,]+\s+from\s+)?['"]([^'"]*(?:types?|interfaces?|models?)[^'"]*)['"]/gi,
+];
+// Common type file/directory patterns
+const TYPE_LOCATIONS = [
+    "types",
+    "types/**",
+    "interfaces",
+    "interfaces/**",
+    "models",
+    "models/**",
+    "@types",
+    "@types/**",
+    "src/types",
+    "src/types/**",
+    "src/interfaces",
+    "src/interfaces/**",
+    "**/*.d.ts",
+];
+/**
+ * Extract type-related imports from file content
+ */
+export function extractTypeImports(content) {
+    const typeImports = new Set();
+    for (const pattern of TYPE_IMPORT_PATTERNS) {
+        pattern.lastIndex = 0;
+        let match;
+        while ((match = pattern.exec(content)) !== null) {
+            typeImports.add(match[1]);
+        }
+    }
+    return Array.from(typeImports);
+}
+/**
+ * Check if a file path looks like a type definition file
+ */
+export function isTypeFile(filePath) {
+    const normalized = filePath.toLowerCase();
+    return (normalized.endsWith(".d.ts") ||
+        normalized.includes("/types/") ||
+        normalized.includes("/interfaces/") ||
+        normalized.includes("/models/") ||
+        normalized.includes("/@types/") ||
+        /\/types?\.(ts|js)$/.test(normalized) ||
+        /\/interfaces?\.(ts|js)$/.test(normalized));
+}
+/**
+ * Find all type definition files in a project
+ */
+export async function findAllTypeFiles(projectPath) {
+    const typeFiles = await glob(TYPE_LOCATIONS, {
+        cwd: projectPath,
+        absolute: true,
+        nodir: true,
+        ignore: ["**/node_modules/**", "**/dist/**", "**/build/**"],
+    });
+    return typeFiles.filter((f) => /\.(ts|tsx|js|jsx)$/.test(f));
+}
+/**
+ * Find type files that are imported by the given files
+ */
+export async function findTypeFilesForFiles(files, projectPath) {
+    const typeFiles = new Set();
+    // Get all type files in the project
+    const allTypes = await findAllTypeFiles(projectPath);
+    const typeFileSet = new Set(allTypes);
+    for (const file of files) {
+        if (!fs.existsSync(file))
+            continue;
+        try {
+            const content = fs.readFileSync(file, "utf-8");
+            const typeImports = extractTypeImports(content);
+            // Also check regular imports that resolve to type files
+            const allImportPattern = /import\s+(?:[\w*{}\s,]+\s+from\s+)?['"]([^'"]+)['"]/g;
+            let match;
+            while ((match = allImportPattern.exec(content)) !== null) {
+                const importPath = match[1];
+                const resolved = resolveImportPath(importPath, file, projectPath);
+                if (resolved && (typeFileSet.has(resolved) || isTypeFile(resolved))) {
+                    if (!files.includes(resolved)) {
+                        typeFiles.add(resolved);
+                    }
+                }
+            }
+        }
+        catch {
+            // Skip files that can't be read
+        }
+    }
+    return Array.from(typeFiles);
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { runServer } from "./server.js";
+runServer().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/dist/output/writer.d.ts

@@ -0,0 +1,34 @@
+export interface ReviewMetadata {
+    sessionName: string;
+    provider: string;
+    model: string;
+    timestamp: string;
+    filesReviewed: string[];
+    tokensUsed?: number;
+    task?: string;
+}
+export interface EgressSummary {
+    projectFilesSent: number;
+    projectFilePaths: string[];
+    externalFilesSent: number;
+    externalFilePaths: string[];
+    externalLocations: string[];
+    blockedFiles: {
+        path: string;
+        reason: string;
+    }[];
+    provider: string;
+}
+/**
+ * Write a review/response to a markdown file
+ */
+export declare function writeReview(projectPath: string, reviewsDir: string, metadata: ReviewMetadata, review: string): string;
+/**
+ * Derive a session name from the conversation context
+ */
+export declare function deriveSessionName(conversationContext: string, fallback?: string): string;
+/**
+ * Write an egress manifest JSON file for audit trail
+ * This records exactly what files were sent to the external LLM
+ */
+export declare function writeEgressManifest(projectPath: string, reviewsDir: string, metadata: ReviewMetadata, egressData: EgressSummary): string;

package/dist/output/writer.js

@@ -0,0 +1,162 @@
+import * as fs from "fs";
+import * as path from "path";
+/**
+ * Generate a slug from a session name
+ */
+function slugify(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .substring(0, 50);
+}
+/**
+ * Validate that reviewsDir is safe (relative, no traversal)
+ */
+function validateReviewsDir(reviewsDir) {
+    // Must be relative
+    if (path.isAbsolute(reviewsDir)) {
+        throw new Error(`reviewsDir must be relative, got: ${reviewsDir}`);
+    }
+    // Must not contain path traversal
+    if (reviewsDir.includes("..")) {
+        throw new Error(`reviewsDir contains path traversal: ${reviewsDir}`);
+    }
+    // Normalize and verify no traversal after normalization
+    const normalized = path.normalize(reviewsDir);
+    if (normalized.startsWith("..")) {
+        throw new Error(`reviewsDir resolves outside project: ${reviewsDir}`);
+    }
+}
+/**
+ * Derive a short task slug from a task description
+ */
+function deriveTaskSlug(task) {
+    // Take first few meaningful words
+    const words = task
+        .toLowerCase()
+        .replace(/[^a-z0-9\s]/g, " ")
+        .split(/\s+/)
+        .filter((w) => w.length > 2)
+        .slice(0, 4);
+    if (words.length === 0) {
+        return "task";
+    }
+    return words.join("-").substring(0, 30);
+}
+/**
+ * Generate base filename (without extension) for output files
+ */
+function generateBaseFilename(metadata) {
+    const sessionSlug = slugify(metadata.sessionName);
+    if (metadata.task) {
+        const taskSlug = deriveTaskSlug(metadata.task);
+        return `${sessionSlug}.${metadata.provider}.${taskSlug}`;
+    }
+    return `${sessionSlug}.${metadata.provider}.review`;
+}
+/**
+ * Ensure output directory exists and return its path
+ */
+function ensureOutputDir(projectPath, reviewsDir) {
+    validateReviewsDir(reviewsDir);
+    const outputDirPath = path.join(projectPath, reviewsDir);
+    if (!fs.existsSync(outputDirPath)) {
+        fs.mkdirSync(outputDirPath, { recursive: true });
+    }
+    return outputDirPath;
+}
+/**
+ * Write a review/response to a markdown file
+ */
+export function writeReview(projectPath, reviewsDir, metadata, review) {
+    const outputDirPath = ensureOutputDir(projectPath, reviewsDir);
+    const filePath = path.join(outputDirPath, `${generateBaseFilename(metadata)}.md`);
+    // Build the document
+    const lines = [];
+    // Header based on task or review
+    if (metadata.task) {
+        lines.push(`# Second Opinion - ${metadata.sessionName}`);
+        lines.push("");
+        lines.push(`**Task:** ${metadata.task.substring(0, 200)}${metadata.task.length > 200 ? "..." : ""}`);
+    }
+    else {
+        lines.push(`# Code Review - ${metadata.sessionName}`);
+    }
+    lines.push("");
+    lines.push(`**Provider:** ${metadata.provider} (${metadata.model})`);
+    lines.push(`**Date:** ${metadata.timestamp}`);
+    if (metadata.tokensUsed) {
+        lines.push(`**Tokens Used:** ${metadata.tokensUsed.toLocaleString()}`);
+    }
+    lines.push("");
+    if (metadata.filesReviewed.length > 0) {
+        lines.push("## Files Analyzed");
+        lines.push("");
+        for (const file of metadata.filesReviewed) {
+            const relativePath = path.relative(projectPath, file);
+            lines.push(`- ${relativePath}`);
+        }
+        lines.push("");
+    }
+    lines.push("---");
+    lines.push("");
+    lines.push(review);
+    lines.push("");
+    lines.push("---");
+    lines.push("*Generated by second-opinion MCP server*");
+    // Write the file
+    fs.writeFileSync(filePath, lines.join("\n"));
+    return filePath;
+}
+/**
+ * Derive a session name from the conversation context
+ */
+export function deriveSessionName(conversationContext, fallback = "review") {
+    // Try to extract from the first user message
+    const userMatch = conversationContext.match(/\*\*User\*\*:\n(.+?)(?:\n|$)/);
+    if (userMatch) {
+        const firstMessage = userMatch[1].trim();
+        // Take first 50 chars, clean up
+        const name = firstMessage
+            .substring(0, 50)
+            .replace(/[^a-zA-Z0-9\s-]/g, "")
+            .trim();
+        if (name.length > 3) {
+            return name;
+        }
+    }
+    return fallback;
+}
+/**
+ * Write an egress manifest JSON file for audit trail
+ * This records exactly what files were sent to the external LLM
+ */
+export function writeEgressManifest(projectPath, reviewsDir, metadata, egressData) {
+    const outputDirPath = ensureOutputDir(projectPath, reviewsDir);
+    const filePath = path.join(outputDirPath, `${generateBaseFilename(metadata)}.egress.json`);
+    // Build the manifest
+    const manifest = {
+        timestamp: metadata.timestamp,
+        provider: egressData.provider,
+        model: metadata.model,
+        sessionName: metadata.sessionName,
+        task: metadata.task || null,
+        egress: {
+            projectFiles: {
+                count: egressData.projectFilesSent,
+                paths: egressData.projectFilePaths.map((p) => path.relative(projectPath, p)),
+            },
+            externalFiles: {
+                count: egressData.externalFilesSent,
+                paths: egressData.externalFilePaths,
+                locations: egressData.externalLocations,
+            },
+            blockedFiles: egressData.blockedFiles,
+            totalFilesSent: egressData.projectFilesSent + egressData.externalFilesSent,
+        },
+    };
+    // Write the file
+    fs.writeFileSync(filePath, JSON.stringify(manifest, null, 2));
+    return filePath;
+}

package/dist/output/writer.test.d.ts

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

package/dist/output/writer.test.js

@@ -0,0 +1,175 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { writeReview, writeEgressManifest, deriveSessionName, } from "./writer.js";
+describe("deriveSessionName", () => {
+    it("extracts name from first user message", () => {
+        const context = "## Conversation Context\n\n**User**:\nFix the login bug\n\n**Claude**:\nI'll look into it.";
+        expect(deriveSessionName(context)).toBe("Fix the login bug");
+    });
+    it("truncates long messages", () => {
+        const longMessage = "A".repeat(100);
+        const context = `**User**:\n${longMessage}\n`;
+        const result = deriveSessionName(context);
+        expect(result.length).toBeLessThanOrEqual(50);
+    });
+    it("returns fallback for empty context", () => {
+        expect(deriveSessionName("")).toBe("review");
+        expect(deriveSessionName("", "custom-fallback")).toBe("custom-fallback");
+    });
+    it("returns fallback for context without user message", () => {
+        const context = "**Claude**:\nHere's the review.";
+        expect(deriveSessionName(context)).toBe("review");
+    });
+    it("strips special characters from name", () => {
+        const context = "**User**:\nFix the `bug` in [auth]!\n";
+        const result = deriveSessionName(context);
+        expect(result).not.toContain("`");
+        expect(result).not.toContain("[");
+        expect(result).not.toContain("!");
+    });
+});
+describe("writeReview", () => {
+    const tmpDir = path.join(os.tmpdir(), "writer-test-" + Date.now());
+    beforeAll(() => {
+        fs.mkdirSync(tmpDir, { recursive: true });
+    });
+    afterAll(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it("creates review file with correct filename for review", () => {
+        const metadata = {
+            sessionName: "Fix Login Bug",
+            provider: "gemini",
+            model: "gemini-2.0-flash-exp",
+            timestamp: "2024-01-01T00:00:00Z",
+            filesReviewed: [],
+        };
+        const filePath = writeReview(tmpDir, "reviews", metadata, "# Review\nLooks good!");
+        expect(fs.existsSync(filePath)).toBe(true);
+        expect(filePath).toContain("fix-login-bug.gemini.review.md");
+    });
+    it("creates review file with task slug when task provided", () => {
+        const metadata = {
+            sessionName: "Auth Refactor",
+            provider: "openai",
+            model: "gpt-4o",
+            timestamp: "2024-01-01T00:00:00Z",
+            filesReviewed: [],
+            task: "Check for security vulnerabilities in the authentication flow",
+        };
+        const filePath = writeReview(tmpDir, "reviews", metadata, "# Analysis\nNo issues found.");
+        expect(filePath).toContain("auth-refactor.openai.check-for-security");
+        expect(filePath.endsWith(".md")).toBe(true);
+    });
+    it("creates output directory if it doesn't exist", () => {
+        const metadata = {
+            sessionName: "Test",
+            provider: "gemini",
+            model: "gemini-2.0-flash-exp",
+            timestamp: "2024-01-01T00:00:00Z",
+            filesReviewed: [],
+        };
+        const filePath = writeReview(tmpDir, "new-dir", metadata, "Review content");
+        expect(fs.existsSync(path.join(tmpDir, "new-dir"))).toBe(true);
+        expect(fs.existsSync(filePath)).toBe(true);
+    });
+    it("includes metadata in review content", () => {
+        const metadata = {
+            sessionName: "Metadata Test",
+            provider: "gemini",
+            model: "gemini-2.0-flash-exp",
+            timestamp: "2024-01-01T00:00:00Z",
+            filesReviewed: [path.join(tmpDir, "src", "file.ts")],
+            tokensUsed: 1000,
+        };
+        const filePath = writeReview(tmpDir, "reviews", metadata, "Review body");
+        const content = fs.readFileSync(filePath, "utf-8");
+        expect(content).toContain("**Provider:** gemini (gemini-2.0-flash-exp)");
+        expect(content).toContain("**Date:** 2024-01-01T00:00:00Z");
+        expect(content).toContain("**Tokens Used:** 1,000");
+        expect(content).toContain("Review body");
+    });
+    it("throws on absolute reviewsDir", () => {
+        const metadata = {
+            sessionName: "Test",
+            provider: "gemini",
+            model: "gemini-2.0-flash-exp",
+            timestamp: "2024-01-01T00:00:00Z",
+            filesReviewed: [],
+        };
+        expect(() => writeReview(tmpDir, "/absolute/path", metadata, "content")).toThrow("reviewsDir must be relative");
+    });
+    it("throws on path traversal in reviewsDir", () => {
+        const metadata = {
+            sessionName: "Test",
+            provider: "gemini",
+            model: "gemini-2.0-flash-exp",
+            timestamp: "2024-01-01T00:00:00Z",
+            filesReviewed: [],
+        };
+        expect(() => writeReview(tmpDir, "../escape", metadata, "content")).toThrow("path traversal");
+    });
+});
+describe("writeEgressManifest", () => {
+    const tmpDir = path.join(os.tmpdir(), "egress-test-" + Date.now());
+    beforeAll(() => {
+        fs.mkdirSync(tmpDir, { recursive: true });
+    });
+    afterAll(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it("creates egress manifest with correct structure", () => {
+        const metadata = {
+            sessionName: "Egress Test",
+            provider: "gemini",
+            model: "gemini-2.0-flash-exp",
+            timestamp: "2024-01-01T00:00:00Z",
+            filesReviewed: [],
+        };
+        const egressData = {
+            projectFilesSent: 5,
+            projectFilePaths: [
+                path.join(tmpDir, "src/a.ts"),
+                path.join(tmpDir, "src/b.ts"),
+            ],
+            externalFilesSent: 1,
+            externalFilePaths: ["/external/file.ts"],
+            externalLocations: ["/external"],
+            blockedFiles: [{ path: "/blocked/secret.ts", reason: "sensitive_path" }],
+            provider: "gemini",
+        };
+        const filePath = writeEgressManifest(tmpDir, "reviews", metadata, egressData);
+        expect(filePath).toContain("egress-test.gemini.review.egress.json");
+        const content = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        expect(content.timestamp).toBe("2024-01-01T00:00:00Z");
+        expect(content.provider).toBe("gemini");
+        expect(content.egress.projectFiles.count).toBe(5);
+        expect(content.egress.externalFiles.count).toBe(1);
+        expect(content.egress.blockedFiles).toHaveLength(1);
+        expect(content.egress.totalFilesSent).toBe(6);
+    });
+    it("relativizes project file paths", () => {
+        const metadata = {
+            sessionName: "Path Test",
+            provider: "gemini",
+            model: "gemini-2.0-flash-exp",
+            timestamp: "2024-01-01T00:00:00Z",
+            filesReviewed: [],
+        };
+        const egressData = {
+            projectFilesSent: 1,
+            projectFilePaths: [path.join(tmpDir, "src", "file.ts")],
+            externalFilesSent: 0,
+            externalFilePaths: [],
+            externalLocations: [],
+            blockedFiles: [],
+            provider: "gemini",
+        };
+        const filePath = writeEgressManifest(tmpDir, "reviews", metadata, egressData);
+        const content = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        // Should be relative path, not absolute
+        expect(content.egress.projectFiles.paths[0]).toBe(path.join("src", "file.ts"));
+    });
+});

package/dist/providers/base.d.ts

@@ -0,0 +1,24 @@
+export interface ReviewRequest {
+    instructions: string;
+    context: string;
+    task?: string;
+    focusAreas?: string[];
+    customPrompt?: string;
+}
+export interface ReviewResponse {
+    review: string;
+    model: string;
+    tokensUsed?: number;
+}
+export interface ReviewProvider {
+    name: string;
+    review(request: ReviewRequest): Promise<ReviewResponse>;
+}
+/**
+ * Get the system prompt based on whether a custom task is provided
+ */
+export declare function getSystemPrompt(hasTask: boolean): string;
+/**
+ * Build the full prompt for the LLM
+ */
+export declare function buildReviewPrompt(request: ReviewRequest): string;

package/dist/providers/base.js

@@ -0,0 +1,77 @@
+/**
+ * Get the system prompt based on whether a custom task is provided
+ */
+export function getSystemPrompt(hasTask) {
+    return hasTask
+        ? "You are an expert software engineer. Complete the requested task thoroughly and provide clear, actionable output."
+        : "You are an expert software engineer performing a code review. Be thorough, constructive, and actionable.";
+}
+/**
+ * Build the full prompt for the LLM
+ */
+export function buildReviewPrompt(request) {
+    const parts = [];
+    // When a task is provided, it becomes the primary objective
+    if (request.task) {
+        parts.push("# Task");
+        parts.push("");
+        parts.push(request.task);
+        parts.push("");
+        // Focus areas if specified
+        if (request.focusAreas && request.focusAreas.length > 0) {
+            parts.push("## Focus Areas");
+            parts.push("");
+            for (const area of request.focusAreas) {
+                parts.push(`- ${area}`);
+            }
+            parts.push("");
+        }
+        // Additional instructions if specified
+        if (request.customPrompt) {
+            parts.push("## Additional Instructions");
+            parts.push("");
+            parts.push(request.customPrompt);
+            parts.push("");
+        }
+        // Include instructions as reference material
+        if (request.instructions) {
+            parts.push("---");
+            parts.push("");
+            parts.push("## Reference Instructions");
+            parts.push("");
+            parts.push("*Use the following instructions as reference where relevant to your task:*");
+            parts.push("");
+            parts.push(request.instructions);
+            parts.push("");
+        }
+    }
+    else {
+        // Default: code review mode
+        parts.push(request.instructions);
+        parts.push("");
+        // Focus areas if specified
+        if (request.focusAreas && request.focusAreas.length > 0) {
+            parts.push("## Specific Focus Areas for This Review");
+            parts.push("");
+            for (const area of request.focusAreas) {
+                parts.push(`- ${area}`);
+            }
+            parts.push("");
+        }
+        // Custom prompt if specified (legacy support)
+        if (request.customPrompt) {
+            parts.push("## Additional Instructions");
+            parts.push("");
+            parts.push(request.customPrompt);
+            parts.push("");
+        }
+    }
+    // Separator
+    parts.push("---");
+    parts.push("");
+    parts.push("# Code Context");
+    parts.push("");
+    // The actual context
+    parts.push(request.context);
+    return parts.join("\n");
+}

package/dist/providers/base.test.d.ts

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

package/dist/providers/base.test.js

@@ -0,0 +1,91 @@
+import { describe, it, expect } from "vitest";
+import { buildReviewPrompt, getSystemPrompt } from "./base.js";
+describe("getSystemPrompt", () => {
+    it("returns task prompt when hasTask is true", () => {
+        const prompt = getSystemPrompt(true);
+        expect(prompt).toContain("Complete the requested task");
+        expect(prompt).not.toContain("code review");
+    });
+    it("returns review prompt when hasTask is false", () => {
+        const prompt = getSystemPrompt(false);
+        expect(prompt).toContain("code review");
+        expect(prompt).toContain("constructive");
+    });
+});
+describe("buildReviewPrompt", () => {
+    it("builds prompt with task as primary objective", () => {
+        const request = {
+            instructions: "Review guidelines here",
+            context: "# Code\n```ts\nconst x = 1;\n```",
+            task: "Analyze security vulnerabilities",
+        };
+        const prompt = buildReviewPrompt(request);
+        expect(prompt).toContain("# Task");
+        expect(prompt).toContain("Analyze security vulnerabilities");
+        expect(prompt).toContain("## Reference Instructions");
+        expect(prompt).toContain("# Code Context");
+        expect(prompt).toContain("const x = 1;");
+    });
+    it("builds prompt in review mode when no task", () => {
+        const request = {
+            instructions: "Review guidelines here",
+            context: "# Code\n```ts\nconst x = 1;\n```",
+        };
+        const prompt = buildReviewPrompt(request);
+        expect(prompt).not.toContain("# Task");
+        expect(prompt).toContain("Review guidelines here");
+        expect(prompt).toContain("# Code Context");
+    });
+    it("includes focus areas when provided", () => {
+        const request = {
+            instructions: "Guidelines",
+            context: "Code",
+            focusAreas: ["Security", "Performance"],
+        };
+        const prompt = buildReviewPrompt(request);
+        expect(prompt).toContain("Focus Areas");
+        expect(prompt).toContain("- Security");
+        expect(prompt).toContain("- Performance");
+    });
+    it("includes focus areas in task mode", () => {
+        const request = {
+            instructions: "Guidelines",
+            context: "Code",
+            task: "Analyze code",
+            focusAreas: ["Security"],
+        };
+        const prompt = buildReviewPrompt(request);
+        expect(prompt).toContain("## Focus Areas");
+        expect(prompt).toContain("- Security");
+    });
+    it("includes custom prompt as additional instructions", () => {
+        const request = {
+            instructions: "Guidelines",
+            context: "Code",
+            customPrompt: "Pay special attention to error handling",
+        };
+        const prompt = buildReviewPrompt(request);
+        expect(prompt).toContain("## Additional Instructions");
+        expect(prompt).toContain("Pay special attention to error handling");
+    });
+    it("includes custom prompt in task mode", () => {
+        const request = {
+            instructions: "Guidelines",
+            context: "Code",
+            task: "Review",
+            customPrompt: "Be concise",
+        };
+        const prompt = buildReviewPrompt(request);
+        expect(prompt).toContain("## Additional Instructions");
+        expect(prompt).toContain("Be concise");
+    });
+    it("separates sections with markdown separators", () => {
+        const request = {
+            instructions: "Guidelines",
+            context: "Code content here",
+        };
+        const prompt = buildReviewPrompt(request);
+        expect(prompt).toContain("---");
+        expect(prompt).toContain("# Code Context");
+    });
+});