@j0hanz/code-review-analyst-mcp 1.3.0 → 1.4.0

package/dist/server.js

@@ -2,6 +2,7 @@ import { InMemoryTaskStore } from '@modelcontextprotocol/sdk/experimental/tasks/
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { readFileSync } from 'node:fs';
 import { findPackageJSON } from 'node:module';
+import { initDiffStore } from './lib/diff-store.js';
 import { getErrorMessage } from './lib/errors.js';
 import { registerAllPrompts } from './prompts/index.js';
 import { registerAllResources } from './resources/index.js';
@@ -14,7 +15,7 @@ const VERSION_FIELD_ERROR = 'missing or invalid version field';
 const SERVER_CAPABILITIES = {
     logging: {},
     completions: {},
-    resources: {},
+    resources: { subscribe: true },
     tools: {},
     tasks: {
         list: {},
@@ -80,6 +81,7 @@ function createMcpServer(taskStore) {
     });
 }
 function registerServerCapabilities(server) {
+    initDiffStore(server);
     registerAllTools(server);
     registerAllResources(server, SERVER_INSTRUCTIONS);
     registerAllPrompts(server, SERVER_INSTRUCTIONS);

package/dist/tools/analyze-complexity.js

@@ -1,4 +1,5 @@
 import { validateDiffBudget } from '../lib/diff-budget.js';
+import { createNoDiffError, getDiff } from '../lib/diff-store.js';
 import { requireToolContract } from '../lib/tool-contracts.js';
 import { registerStructuredToolTask } from '../lib/tool-factory.js';
 import { AnalyzeComplexityInputSchema } from '../schemas/inputs.js';
@@ -10,18 +11,11 @@ Identify potential bottlenecks arising from loop nesting, recursive calls, and a
 Return strict JSON only.
 `;
 const TOOL_CONTRACT = requireToolContract('analyze_time_space_complexity');
-function formatOptionalLine(label, value) {
-    return value === undefined ? '' : `\n${label}: ${value}`;
-}
-function buildAnalyzeComplexityPrompt(input) {
-    const languageLine = formatOptionalLine('Language', input.language);
-    return `${languageLine}\nDiff:\n${input.diff}`.trimStart();
-}
 export function registerAnalyzeComplexityTool(server) {
     registerStructuredToolTask(server, {
         name: 'analyze_time_space_complexity',
         title: 'Analyze Time & Space Complexity',
-        description: 'Analyze Big-O time and space complexity of code changes and detect performance degradations.',
+        description: 'Analyze Big-O complexity of the cached diff changes. Call generate_diff first.',
         inputSchema: AnalyzeComplexityInputSchema,
         fullInputSchema: AnalyzeComplexityInputSchema,
         resultSchema: AnalyzeComplexityResultSchema,
@@ -32,14 +26,26 @@ export function registerAnalyzeComplexityTool(server) {
         ...(TOOL_CONTRACT.thinkingBudget !== undefined
             ? { thinkingBudget: TOOL_CONTRACT.thinkingBudget }
             : undefined),
-        validateInput: (input) => validateDiffBudget(input.diff),
+        validateInput: () => {
+            const slot = getDiff();
+            if (!slot)
+                return createNoDiffError();
+            return validateDiffBudget(slot.diff);
+        },
         formatOutcome: (result) => result.isDegradation
             ? 'Performance degradation detected'
             : 'No degradation',
         formatOutput: (result) => `Complexity Analysis: Time=${result.timeComplexity}, Space=${result.spaceComplexity}. ${result.explanation}`,
-        buildPrompt: (input) => ({
-            systemInstruction: SYSTEM_INSTRUCTION,
-            prompt: buildAnalyzeComplexityPrompt(input),
-        }),
+        buildPrompt: (input) => {
+            const slot = getDiff();
+            const diff = slot?.diff ?? '';
+            const languageLine = input.language
+                ? `\nLanguage: ${input.language}`
+                : '';
+            return {
+                systemInstruction: SYSTEM_INSTRUCTION,
+                prompt: `${languageLine}\nDiff:\n${diff}`.trimStart(),
+            };
+        },
     });
 }

package/dist/tools/analyze-pr-impact.js

@@ -1,5 +1,6 @@
 import { validateDiffBudget } from '../lib/diff-budget.js';
 import { computeDiffStatsAndSummaryFromFiles, parseDiffFiles, } from '../lib/diff-parser.js';
+import { createNoDiffError, getDiff } from '../lib/diff-store.js';
 import { requireToolContract } from '../lib/tool-contracts.js';
 import { registerStructuredToolTask } from '../lib/tool-factory.js';
 import { AnalyzePrImpactInputSchema } from '../schemas/inputs.js';
@@ -14,25 +15,11 @@ const TOOL_CONTRACT = requireToolContract('analyze_pr_impact');
 function formatLanguageSegment(language) {
     return language ? `\nLanguage: ${language}` : '';
 }
-function buildAnalyzePrImpactPrompt(input) {
-    const files = parseDiffFiles(input.diff);
-    const { stats, summary: fileSummary } = computeDiffStatsAndSummaryFromFiles(files);
-    const languageSegment = formatLanguageSegment(input.language);
-    return `
-Repository: ${input.repository}${languageSegment}
-Change Stats: ${stats.files} files, +${stats.added} lines, -${stats.deleted} lines.
-Changed Files:
-${fileSummary}
-
-Diff:
-${input.diff}
-`;
-}
 export function registerAnalyzePrImpactTool(server) {
     registerStructuredToolTask(server, {
         name: 'analyze_pr_impact',
         title: 'Analyze PR Impact',
-        description: 'Assess the impact and risk of a pull request diff.',
+        description: 'Assess the impact and risk of the cached diff. Call generate_diff first.',
         inputSchema: AnalyzePrImpactInputSchema,
         fullInputSchema: AnalyzePrImpactInputSchema,
         resultSchema: PrImpactResultSchema,
@@ -40,12 +27,32 @@ export function registerAnalyzePrImpactTool(server) {
         model: TOOL_CONTRACT.model,
         timeoutMs: TOOL_CONTRACT.timeoutMs,
         maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
-        validateInput: (input) => validateDiffBudget(input.diff),
+        validateInput: () => {
+            const slot = getDiff();
+            if (!slot)
+                return createNoDiffError();
+            return validateDiffBudget(slot.diff);
+        },
         formatOutcome: (result) => `severity: ${result.severity}`,
         formatOutput: (result) => `Impact Analysis (${result.severity}): ${result.summary}`,
-        buildPrompt: (input) => ({
-            systemInstruction: SYSTEM_INSTRUCTION,
-            prompt: buildAnalyzePrImpactPrompt(input),
-        }),
+        buildPrompt: (input) => {
+            const slot = getDiff();
+            const diff = slot?.diff ?? '';
+            const files = parseDiffFiles(diff);
+            const { stats, summary: fileSummary } = computeDiffStatsAndSummaryFromFiles(files);
+            const languageSegment = formatLanguageSegment(input.language);
+            return {
+                systemInstruction: SYSTEM_INSTRUCTION,
+                prompt: `
+Repository: ${input.repository}${languageSegment}
+Change Stats: ${stats.files} files, +${stats.added} lines, -${stats.deleted} lines.
+Changed Files:
+${fileSummary}
+
+Diff:
+${diff}
+`,
+            };
+        },
     });
 }

package/dist/tools/detect-api-breaking.js

@@ -1,4 +1,5 @@
 import { validateDiffBudget } from '../lib/diff-budget.js';
+import { createNoDiffError, getDiff } from '../lib/diff-store.js';
 import { requireToolContract } from '../lib/tool-contracts.js';
 import { registerStructuredToolTask } from '../lib/tool-factory.js';
 import { DetectApiBreakingInputSchema } from '../schemas/inputs.js';
@@ -10,18 +11,11 @@ Classify each breaking change with its affected element, nature of change, consu
 Return strict JSON only.
 `;
 const TOOL_CONTRACT = requireToolContract('detect_api_breaking_changes');
-function formatOptionalLine(label, value) {
-    return value === undefined ? '' : `\n${label}: ${value}`;
-}
-function buildDetectApiBreakingPrompt(input) {
-    const languageLine = formatOptionalLine('Language', input.language);
-    return `${languageLine}\nDiff:\n${input.diff}`.trimStart();
-}
 export function registerDetectApiBreakingTool(server) {
     registerStructuredToolTask(server, {
         name: 'detect_api_breaking_changes',
         title: 'Detect API Breaking Changes',
-        description: 'Detect breaking changes to public APIs, interfaces, and contracts in a unified diff.',
+        description: 'Detect breaking changes to public APIs in the cached diff. Call generate_diff first.',
         inputSchema: DetectApiBreakingInputSchema,
         fullInputSchema: DetectApiBreakingInputSchema,
         resultSchema: DetectApiBreakingResultSchema,
@@ -29,14 +23,26 @@ export function registerDetectApiBreakingTool(server) {
         model: TOOL_CONTRACT.model,
         timeoutMs: TOOL_CONTRACT.timeoutMs,
         maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
-        validateInput: (input) => validateDiffBudget(input.diff),
+        validateInput: () => {
+            const slot = getDiff();
+            if (!slot)
+                return createNoDiffError();
+            return validateDiffBudget(slot.diff);
+        },
         formatOutcome: (result) => `${result.breakingChanges.length} breaking change(s) found`,
         formatOutput: (result) => result.hasBreakingChanges
             ? `API Breaking Changes: ${result.breakingChanges.length} found.`
             : 'No API breaking changes detected.',
-        buildPrompt: (input) => ({
-            systemInstruction: SYSTEM_INSTRUCTION,
-            prompt: buildDetectApiBreakingPrompt(input),
-        }),
+        buildPrompt: (input) => {
+            const slot = getDiff();
+            const diff = slot?.diff ?? '';
+            const languageLine = input.language
+                ? `\nLanguage: ${input.language}`
+                : '';
+            return {
+                systemInstruction: SYSTEM_INSTRUCTION,
+                prompt: `${languageLine}\nDiff:\n${diff}`.trimStart(),
+            };
+        },
     });
 }

package/dist/tools/generate-diff.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerGenerateDiffTool(server: McpServer): void;

package/dist/tools/generate-diff.js

@@ -0,0 +1,71 @@
+import { spawnSync } from 'node:child_process';
+import { z } from 'zod';
+import { cleanDiff, isEmptyDiff, NOISY_EXCLUDE_PATHSPECS, } from '../lib/diff-cleaner.js';
+import { computeDiffStatsFromFiles, parseDiffFiles, } from '../lib/diff-parser.js';
+import { DIFF_RESOURCE_URI, storeDiff } from '../lib/diff-store.js';
+import { createErrorToolResponse, createToolResponse, } from '../lib/tool-response.js';
+const GIT_TIMEOUT_MS = 30_000;
+const GIT_MAX_BUFFER = 10 * 1024 * 1024; // 10 MB
+function buildGitArgs(mode) {
+    const args = ['diff', '--no-color', '--no-ext-diff'];
+    if (mode === 'staged') {
+        args.push('--cached');
+    }
+    // '--' separates flags from pathspecs. Everything after it is a
+    // pathspec, never interpreted as a flag — prevents flag injection.
+    args.push('--', ...NOISY_EXCLUDE_PATHSPECS);
+    return args;
+}
+function describeModeHint(mode) {
+    return mode === 'staged'
+        ? 'staged with git add'
+        : 'modified but not yet staged (git add)';
+}
+export function registerGenerateDiffTool(server) {
+    server.registerTool('generate_diff', {
+        description: 'Generate a diff of the current branch working changes and cache it for all review tools. You MUST call this tool before calling any other review tool. Use "unstaged" for working-tree changes not yet staged, or "staged" for changes already added with git add.',
+        inputSchema: {
+            mode: z
+                .enum(['unstaged', 'staged'])
+                .describe('"unstaged": working-tree changes not yet staged. "staged": changes added to the index with git add.'),
+        },
+    }, (input) => {
+        const { mode } = input;
+        const args = buildGitArgs(mode);
+        // spawnSync with an explicit args array — no shell, no interpolation.
+        // 'git' is resolved via PATH which is controlled by the server environment.
+        // eslint-disable-next-line sonarjs/no-os-command-from-path
+        const result = spawnSync('git', args, {
+            cwd: process.cwd(),
+            encoding: 'utf8',
+            maxBuffer: GIT_MAX_BUFFER,
+            timeout: GIT_TIMEOUT_MS,
+        });
+        if (result.error) {
+            return createErrorToolResponse('E_GENERATE_DIFF', `Failed to run git: ${result.error.message}. Ensure git is installed and the working directory is a git repository.`, undefined, { retryable: false, kind: 'internal' });
+        }
+        if (result.status !== 0) {
+            const stderr = result.stderr.trim();
+            return createErrorToolResponse('E_GENERATE_DIFF', `git exited with code ${String(result.status)}: ${stderr || 'unknown error'}. Ensure the working directory is a git repository.`, undefined, { retryable: false, kind: 'internal' });
+        }
+        const cleaned = cleanDiff(result.stdout);
+        if (isEmptyDiff(cleaned)) {
+            return createErrorToolResponse('E_NO_CHANGES', `No ${mode} changes found in the current branch. Make sure you have changes that are ${describeModeHint(mode)}.`, undefined, { retryable: false, kind: 'validation' });
+        }
+        const parsedFiles = parseDiffFiles(cleaned);
+        const stats = computeDiffStatsFromFiles(parsedFiles);
+        const generatedAt = new Date().toISOString();
+        storeDiff({ diff: cleaned, stats, generatedAt, mode });
+        const summary = `Diff cached at ${DIFF_RESOURCE_URI} — ${stats.files} file(s), +${stats.added} -${stats.deleted}. All review tools are now ready.`;
+        return createToolResponse({
+            ok: true,
+            result: {
+                diffRef: DIFF_RESOURCE_URI,
+                stats,
+                generatedAt,
+                mode,
+                message: summary,
+            },
+        }, summary);
+    });
+}

package/dist/tools/generate-review-summary.js

@@ -1,5 +1,6 @@
 import { validateDiffBudget } from '../lib/diff-budget.js';
 import { computeDiffStatsFromFiles, parseDiffFiles, } from '../lib/diff-parser.js';
+import { createNoDiffError, getDiff } from '../lib/diff-store.js';
 import { requireToolContract } from '../lib/tool-contracts.js';
 import { registerStructuredToolTask } from '../lib/tool-factory.js';
 import { GenerateReviewSummaryInputSchema } from '../schemas/inputs.js';
@@ -13,36 +14,14 @@ You are a senior code reviewer. Summarize this PR with precision: risk level, ke
 Be specific — name the exact logic changed, not generic patterns.
 Return strict JSON only.
 `;
-const statsCache = new WeakMap();
-function getCachedStats(input) {
-    const cached = statsCache.get(input);
-    if (cached) {
-        return cached;
-    }
-    const parsedFiles = parseDiffFiles(input.diff);
-    const stats = computeDiffStatsFromFiles(parsedFiles);
-    statsCache.set(input, stats);
-    return stats;
-}
 function formatLanguageSegment(language) {
     return language ? `\nLanguage: ${language}` : '';
 }
-function buildReviewSummaryPrompt(input) {
-    const stats = getCachedStats(input);
-    const languageSegment = formatLanguageSegment(input.language);
-    return `
-Repository: ${input.repository}${languageSegment}
-Stats: ${stats.files} files, +${stats.added}, -${stats.deleted}
-
-Diff:
-${input.diff}
-`;
-}
 export function registerGenerateReviewSummaryTool(server) {
     registerStructuredToolTask(server, {
         name: 'generate_review_summary',
         title: 'Generate Review Summary',
-        description: 'Summarize a pull request diff and assess high-level risk.',
+        description: 'Summarize the cached diff and assess high-level risk. Call generate_diff first.',
         inputSchema: GenerateReviewSummaryInputSchema,
         fullInputSchema: GenerateReviewSummaryInputSchema,
         resultSchema: ReviewSummaryModelSchema,
@@ -50,11 +29,18 @@ export function registerGenerateReviewSummaryTool(server) {
         model: TOOL_CONTRACT.model,
         timeoutMs: TOOL_CONTRACT.timeoutMs,
         maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
-        validateInput: (input) => validateDiffBudget(input.diff),
+        validateInput: () => {
+            const slot = getDiff();
+            if (!slot)
+                return createNoDiffError();
+            return validateDiffBudget(slot.diff);
+        },
         formatOutcome: (result) => `risk: ${result.overallRisk}`,
         transformResult: (input, result) => {
-            const stats = getCachedStats(input);
-            statsCache.delete(input);
+            const slot = getDiff();
+            const diff = slot?.diff ?? '';
+            const parsedFiles = parseDiffFiles(diff);
+            const stats = computeDiffStatsFromFiles(parsedFiles);
             return {
                 ...result,
                 stats: {
@@ -65,9 +51,22 @@ export function registerGenerateReviewSummaryTool(server) {
             };
         },
         formatOutput: (result) => `Review Summary: ${result.summary}\nRecommendation: ${result.recommendation}`,
-        buildPrompt: (input) => ({
-            systemInstruction: SYSTEM_INSTRUCTION,
-            prompt: buildReviewSummaryPrompt(input),
-        }),
+        buildPrompt: (input) => {
+            const slot = getDiff();
+            const diff = slot?.diff ?? '';
+            const parsedFiles = parseDiffFiles(diff);
+            const stats = computeDiffStatsFromFiles(parsedFiles);
+            const languageSegment = formatLanguageSegment(input.language);
+            return {
+                systemInstruction: SYSTEM_INSTRUCTION,
+                prompt: `
+Repository: ${input.repository}${languageSegment}
+Stats: ${stats.files} files, +${stats.added}, -${stats.deleted}
+
+Diff:
+${diff}
+`,
+            };
+        },
     });
 }

package/dist/tools/generate-test-plan.js

@@ -1,5 +1,6 @@
 import { validateDiffBudget } from '../lib/diff-budget.js';
 import { computeDiffStatsAndPathsFromFiles, parseDiffFiles, } from '../lib/diff-parser.js';
+import { createNoDiffError, getDiff } from '../lib/diff-store.js';
 import { requireToolContract } from '../lib/tool-contracts.js';
 import { registerStructuredToolTask } from '../lib/tool-factory.js';
 import { GenerateTestPlanInputSchema } from '../schemas/inputs.js';
@@ -14,26 +15,11 @@ const TOOL_CONTRACT = requireToolContract('generate_test_plan');
 function formatOptionalLine(label, value) {
     return value === undefined ? '' : `\n${label}: ${value}`;
 }
-function buildGenerateTestPlanPrompt(input) {
-    const parsedFiles = parseDiffFiles(input.diff);
-    const { stats, paths } = computeDiffStatsAndPathsFromFiles(parsedFiles);
-    const languageLine = formatOptionalLine('Language', input.language);
-    const frameworkLine = formatOptionalLine('Test Framework', input.testFramework);
-    const maxCasesLine = formatOptionalLine('Max Test Cases', input.maxTestCases);
-    return `
-Repository: ${input.repository}${languageLine}${frameworkLine}${maxCasesLine}
-Stats: ${stats.files} files, +${stats.added}, -${stats.deleted}
-Changed Files: ${paths.join(', ')}
-
-Diff:
-${input.diff}
-`;
-}
 export function registerGenerateTestPlanTool(server) {
     registerStructuredToolTask(server, {
         name: 'generate_test_plan',
         title: 'Generate Test Plan',
-        description: 'Create a test plan covering the changes in the diff.',
+        description: 'Create a test plan covering the cached diff changes. Call generate_diff first.',
         inputSchema: GenerateTestPlanInputSchema,
         fullInputSchema: GenerateTestPlanInputSchema,
         resultSchema: TestPlanResultSchema,
@@ -44,19 +30,37 @@ export function registerGenerateTestPlanTool(server) {
         ...(TOOL_CONTRACT.thinkingBudget !== undefined
             ? { thinkingBudget: TOOL_CONTRACT.thinkingBudget }
             : undefined),
-        validateInput: (input) => validateDiffBudget(input.diff),
+        validateInput: () => {
+            const slot = getDiff();
+            if (!slot)
+                return createNoDiffError();
+            return validateDiffBudget(slot.diff);
+        },
         formatOutcome: (result) => `${result.testCases.length} test cases`,
         formatOutput: (result) => `Test Plan: ${result.summary}\n${result.testCases.length} cases proposed.`,
         transformResult: (input, result) => {
             const cappedTestCases = result.testCases.slice(0, input.maxTestCases ?? result.testCases.length);
+            return { ...result, testCases: cappedTestCases };
+        },
+        buildPrompt: (input) => {
+            const slot = getDiff();
+            const diff = slot?.diff ?? '';
+            const parsedFiles = parseDiffFiles(diff);
+            const { stats, paths } = computeDiffStatsAndPathsFromFiles(parsedFiles);
+            const languageLine = formatOptionalLine('Language', input.language);
+            const frameworkLine = formatOptionalLine('Test Framework', input.testFramework);
+            const maxCasesLine = formatOptionalLine('Max Test Cases', input.maxTestCases);
             return {
-                ...result,
-                testCases: cappedTestCases,
+                systemInstruction: SYSTEM_INSTRUCTION,
+                prompt: `
+Repository: ${input.repository}${languageLine}${frameworkLine}${maxCasesLine}
+Stats: ${stats.files} files, +${stats.added}, -${stats.deleted}
+Changed Files: ${paths.join(', ')}
+
+Diff:
+${diff}
+`,
             };
         },
-        buildPrompt: (input) => ({
-            systemInstruction: SYSTEM_INSTRUCTION,
-            prompt: buildGenerateTestPlanPrompt(input),
-        }),
     });
 }

package/dist/tools/index.js

@@ -1,11 +1,13 @@
 import { registerAnalyzeComplexityTool } from './analyze-complexity.js';
 import { registerAnalyzePrImpactTool } from './analyze-pr-impact.js';
 import { registerDetectApiBreakingTool } from './detect-api-breaking.js';
+import { registerGenerateDiffTool } from './generate-diff.js';
 import { registerGenerateReviewSummaryTool } from './generate-review-summary.js';
 import { registerGenerateTestPlanTool } from './generate-test-plan.js';
 import { registerInspectCodeQualityTool } from './inspect-code-quality.js';
 import { registerSuggestSearchReplaceTool } from './suggest-search-replace.js';
 const TOOL_REGISTRARS = [
+    registerGenerateDiffTool,
     registerAnalyzePrImpactTool,
     registerGenerateReviewSummaryTool,
     registerInspectCodeQualityTool,

package/dist/tools/inspect-code-quality.js

@@ -1,6 +1,7 @@
 import { validateContextBudget } from '../lib/context-budget.js';
 import { validateDiffBudget } from '../lib/diff-budget.js';
 import { computeDiffStatsAndSummaryFromFiles, parseDiffFiles, } from '../lib/diff-parser.js';
+import { createNoDiffError, getDiff } from '../lib/diff-store.js';
 import { requireToolContract } from '../lib/tool-contracts.js';
 import { registerStructuredToolTask } from '../lib/tool-factory.js';
 import { InspectCodeQualityInputSchema } from '../schemas/inputs.js';
@@ -49,31 +50,11 @@ ${sanitizeContent(file.content)}
     }
     return `${FILE_CONTEXT_HEADING}${fileBlocks.join('\n')}`;
 }
-function buildInspectPrompt(input) {
-    const parsedFiles = parseDiffFiles(input.diff);
-    const { summary: fileSummary } = computeDiffStatsAndSummaryFromFiles(parsedFiles);
-    const fileContext = formatFileContext(input.files);
-    const languageLine = formatOptionalLine('Language', input.language);
-    const maxFindingsLine = formatOptionalLine('Max Findings', input.maxFindings);
-    const noFilesNote = !input.files?.length
-        ? '\nNote: No file context provided. Leave contextualInsights empty.'
-        : '';
-    return `
-Repository: ${input.repository}${languageLine}
-Focus Areas: ${input.focusAreas?.join(', ') ?? DEFAULT_FOCUS_AREAS}${maxFindingsLine}${noFilesNote}
-Changed Files:
-${fileSummary}
-
-Diff:
-${input.diff}
-${fileContext}
-`;
-}
 export function registerInspectCodeQualityTool(server) {
     registerStructuredToolTask(server, {
         name: 'inspect_code_quality',
         title: 'Inspect Code Quality',
-        description: 'Deep-dive code review with optional file context.',
+        description: 'Deep-dive code review with optional file context. Call generate_diff first.',
         inputSchema: InspectCodeQualityInputSchema,
         fullInputSchema: InspectCodeQualityInputSchema,
         resultSchema: CodeQualityOutputSchema,
@@ -89,13 +70,16 @@ export function registerInspectCodeQualityTool(server) {
             const fileCount = input.files?.length;
             return fileCount ? `+${fileCount} files` : '';
         },
-        formatOutcome: (result) => `${result.findings.length} findings, risk: ${result.overallRisk}`,
         validateInput: (input) => {
-            const diffError = validateDiffBudget(input.diff);
+            const slot = getDiff();
+            if (!slot)
+                return createNoDiffError();
+            const diffError = validateDiffBudget(slot.diff);
             if (diffError)
                 return diffError;
-            return validateContextBudget(input.diff, input.files);
+            return validateContextBudget(slot.diff, input.files);
         },
+        formatOutcome: (result) => `${result.findings.length} findings, risk: ${result.overallRisk}`,
         formatOutput: (result) => {
             const count = result.findings.length;
             const total = result.totalFindings ?? count;
@@ -109,9 +93,30 @@ export function registerInspectCodeQualityTool(server) {
             const cappedFindings = capFindings(result.findings, input.maxFindings);
             return { ...result, findings: cappedFindings, totalFindings };
         },
-        buildPrompt: (input) => ({
-            systemInstruction: SYSTEM_INSTRUCTION,
-            prompt: buildInspectPrompt(input),
-        }),
+        buildPrompt: (input) => {
+            const slot = getDiff();
+            const diff = slot?.diff ?? '';
+            const parsedFiles = parseDiffFiles(diff);
+            const { summary: fileSummary } = computeDiffStatsAndSummaryFromFiles(parsedFiles);
+            const fileContext = formatFileContext(input.files);
+            const languageLine = formatOptionalLine('Language', input.language);
+            const maxFindingsLine = formatOptionalLine('Max Findings', input.maxFindings);
+            const noFilesNote = !input.files?.length
+                ? '\nNote: No file context provided. Leave contextualInsights empty.'
+                : '';
+            return {
+                systemInstruction: SYSTEM_INSTRUCTION,
+                prompt: `
+Repository: ${input.repository}${languageLine}
+Focus Areas: ${input.focusAreas?.join(', ') ?? DEFAULT_FOCUS_AREAS}${maxFindingsLine}${noFilesNote}
+Changed Files:
+${fileSummary}
+
+Diff:
+${diff}
+${fileContext}
+`,
+            };
+        },
     });
 }

package/dist/tools/suggest-search-replace.js

@@ -1,5 +1,6 @@
 import { validateDiffBudget } from '../lib/diff-budget.js';
 import { extractChangedPathsFromFiles, parseDiffFiles, } from '../lib/diff-parser.js';
+import { createNoDiffError, getDiff } from '../lib/diff-store.js';
 import { requireToolContract } from '../lib/tool-contracts.js';
 import { registerStructuredToolTask } from '../lib/tool-factory.js';
 import { SuggestSearchReplaceInputSchema } from '../schemas/inputs.js';
@@ -14,23 +15,11 @@ const TOOL_CONTRACT = requireToolContract('suggest_search_replace');
 function formatPatchCount(count) {
     return `${count} ${count === 1 ? 'patch' : 'patches'}`;
 }
-function buildSuggestSearchReplacePrompt(input) {
-    const files = parseDiffFiles(input.diff);
-    const paths = extractChangedPathsFromFiles(files);
-    return `
-Finding: ${input.findingTitle}
-Details: ${input.findingDetails}
-Changed Files: ${paths.join(', ')}
-
-Diff:
-${input.diff}
-`;
-}
 export function registerSuggestSearchReplaceTool(server) {
     registerStructuredToolTask(server, {
         name: 'suggest_search_replace',
         title: 'Suggest Search & Replace',
-        description: 'Generate search-and-replace blocks to fix a finding.',
+        description: 'Generate search-and-replace blocks to fix a finding from the cached diff. Call generate_diff first.',
         inputSchema: SuggestSearchReplaceInputSchema,
         fullInputSchema: SuggestSearchReplaceInputSchema,
         resultSchema: SearchReplaceResultSchema,
@@ -41,16 +30,34 @@ export function registerSuggestSearchReplaceTool(server) {
         ...(TOOL_CONTRACT.thinkingBudget !== undefined
             ? { thinkingBudget: TOOL_CONTRACT.thinkingBudget }
             : undefined),
-        validateInput: (input) => validateDiffBudget(input.diff),
+        validateInput: () => {
+            const slot = getDiff();
+            if (!slot)
+                return createNoDiffError();
+            return validateDiffBudget(slot.diff);
+        },
         formatOutcome: (result) => formatPatchCount(result.blocks.length),
         formatOutput: (result) => {
             const count = result.blocks.length;
             const patches = formatPatchCount(count);
             return `${result.summary}\n${patches} • Checklist: ${result.validationChecklist.join(' | ')}`;
         },
-        buildPrompt: (input) => ({
-            systemInstruction: SYSTEM_INSTRUCTION,
-            prompt: buildSuggestSearchReplacePrompt(input),
-        }),
+        buildPrompt: (input) => {
+            const slot = getDiff();
+            const diff = slot?.diff ?? '';
+            const files = parseDiffFiles(diff);
+            const paths = extractChangedPathsFromFiles(files);
+            return {
+                systemInstruction: SYSTEM_INSTRUCTION,
+                prompt: `
+Finding: ${input.findingTitle}
+Details: ${input.findingDetails}
+Changed Files: ${paths.join(', ')}
+
+Diff:
+${diff}
+`,
+            };
+        },
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@j0hanz/code-review-analyst-mcp",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "mcpName": "io.github.j0hanz/code-review-analyst",
   "description": "Gemini-powered MCP server for code review analysis.",
   "type": "module",
@@ -32,7 +32,6 @@
   },
   "scripts": {
     "clean": "node scripts/tasks.mjs clean",
-    "validate:instructions": "node scripts/tasks.mjs validate:instructions",
     "build": "node scripts/tasks.mjs build",
     "copy:assets": "node scripts/tasks.mjs copy:assets",
     "prepare": "npm run build",