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

package/dist/lib/tool-factory.d.ts

@@ -1,11 +1,39 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { ZodRawShapeCompat } from '@modelcontextprotocol/sdk/server/zod-compat.js';
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
 import { z } from 'zod';
+import { type DiffSlot } from './diff-store.js';
 import { createErrorToolResponse } from './tool-response.js';
 export interface PromptParts {
     systemInstruction: string;
     prompt: string;
 }
+/**
+ * Immutable snapshot of server-side state captured once at the start of a
+ * tool execution, before `validateInput` runs.  Threading it through both
+ * `validateInput` and `buildPrompt` eliminates the TOCTOU gap that would
+ * otherwise allow a concurrent `generate_diff` call to replace the cached
+ * diff between the budget check and prompt assembly.
+ */
+export interface ToolExecutionContext {
+    readonly diffSlot: DiffSlot | undefined;
+}
+type ProgressToken = string | number;
+interface ProgressNotificationParams {
+    progressToken: ProgressToken;
+    progress: number;
+    total?: number;
+    message?: string;
+}
+interface ProgressExtra {
+    _meta?: {
+        progressToken?: unknown;
+    };
+    sendNotification: (notification: {
+        method: 'notifications/progress';
+        params: ProgressNotificationParams;
+    }) => Promise<void>;
+}
 export interface StructuredToolTaskConfig<TInput extends object = Record<string, unknown>, TResult extends object = Record<string, unknown>, TFinal extends TResult = TResult> {
     /** Tool name registered with the MCP server (e.g. 'analyze_pr_impact'). */
     name: string;
@@ -24,9 +52,9 @@ export interface StructuredToolTaskConfig<TInput extends object = Record<string,
     /** Stable error code returned on failure (e.g. 'E_INSPECT_QUALITY'). */
     errorCode: string;
     /** Optional post-processing hook called after resultSchema.parse(). The return value replaces the parsed result. */
-    transformResult?: (input: TInput, result: TResult) => TFinal;
+    transformResult?: (input: TInput, result: TResult, ctx: ToolExecutionContext) => TFinal;
     /** Optional validation hook for input parameters. */
-    validateInput?: (input: TInput) => Promise<ReturnType<typeof createErrorToolResponse> | undefined> | ReturnType<typeof createErrorToolResponse> | undefined;
+    validateInput?: (input: TInput, ctx: ToolExecutionContext) => Promise<ReturnType<typeof createErrorToolResponse> | undefined> | ReturnType<typeof createErrorToolResponse> | undefined;
     /** Optional Gemini model to use (e.g. 'gemini-2.5-pro'). */
     model?: string;
     /** Optional thinking budget in tokens. */
@@ -44,6 +72,11 @@ export interface StructuredToolTaskConfig<TInput extends object = Record<string,
     /** Optional short outcome suffix for the completion progress message (e.g., "3 findings"). */
     formatOutcome?: (result: TFinal) => string;
     /** Builds the system instruction and user prompt from parsed tool input. */
-    buildPrompt: (input: TInput) => PromptParts;
+    buildPrompt: (input: TInput, ctx: ToolExecutionContext) => PromptParts;
 }
+export declare function wrapToolHandler<TInput, TResult extends CallToolResult>(options: {
+    toolName: string;
+    progressContext?: (input: TInput) => string;
+}, handler: (input: TInput, extra: ProgressExtra) => Promise<TResult> | TResult): (input: TInput, extra: ProgressExtra) => Promise<TResult>;
 export declare function registerStructuredToolTask<TInput extends object, TResult extends object = Record<string, unknown>, TFinal extends TResult = TResult>(server: McpServer, config: StructuredToolTaskConfig<TInput, TResult, TFinal>): void;
+export {};

package/dist/lib/tool-factory.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { DefaultOutputSchema } from '../schemas/outputs.js';
+import { getDiff } from './diff-store.js';
 import { getErrorMessage, RETRYABLE_UPSTREAM_ERROR_PATTERN } from './errors.js';
 import { stripJsonSchemaConstraints } from './gemini-schema.js';
 import { generateStructuredJson, getCurrentRequestId } from './gemini.js';
@@ -217,6 +218,43 @@ function createGeminiLogger(server, taskId) {
         }
     };
 }
+export function wrapToolHandler(options, handler) {
+    return async (input, extra) => {
+        const context = normalizeProgressContext(options.progressContext?.(input));
+        // Start progress (0/1)
+        await sendTaskProgress(extra, {
+            current: 0,
+            total: 1,
+            message: formatProgressStep(options.toolName, context, 'starting'),
+        });
+        try {
+            const result = await handler(input, extra);
+            // End progress (1/1)
+            const outcome = result.isError ? 'failed' : 'completed';
+            const success = !result.isError;
+            await sendTaskProgress(extra, {
+                current: 1,
+                total: 1,
+                message: formatProgressCompletion(options.toolName, context, outcome, success),
+            });
+            return result;
+        }
+        catch (error) {
+            // Progress is best-effort; must never mask the original error.
+            try {
+                await sendTaskProgress(extra, {
+                    current: 1,
+                    total: 1,
+                    message: formatProgressCompletion(options.toolName, context, 'failed', false),
+                });
+            }
+            catch {
+                // Swallow progress delivery errors so the original error propagates.
+            }
+            throw error;
+        }
+    };
+}
 export function registerStructuredToolTask(server, config) {
     const responseSchema = createGeminiResponseSchema({
         geminiSchema: config.geminiSchema,
@@ -260,9 +298,14 @@ export function registerStructuredToolTask(server, config) {
                     const onLog = createGeminiLogger(server, task.taskId);
                     const inputRecord = parseToolInput(input, config.fullInputSchema);
                     progressContext = normalizeProgressContext(config.progressContext?.(inputRecord));
+                    // Snapshot the diff slot ONCE before any async work so that
+                    // validateInput and buildPrompt observe the same state. Without
+                    // this, a concurrent generate_diff call between the two awaits
+                    // could replace the slot and silently bypass the budget check.
+                    const ctx = { diffSlot: getDiff() };
                     await reportProgressStepUpdate(reportProgress, config.name, progressContext, 0, 'starting');
                     if (config.validateInput) {
-                        const validationError = await config.validateInput(inputRecord);
+                        const validationError = await config.validateInput(inputRecord, ctx);
                         if (validationError) {
                             const validationMessage = validationError.structuredContent.error?.message ??
                                 INPUT_VALIDATION_FAILED;
@@ -273,7 +316,7 @@ export function registerStructuredToolTask(server, config) {
                         }
                     }
                     await reportProgressStepUpdate(reportProgress, config.name, progressContext, 1, 'preparing');
-                    const promptParts = config.buildPrompt(inputRecord);
+                    const promptParts = config.buildPrompt(inputRecord, ctx);
                     const { prompt } = promptParts;
                     const { systemInstruction } = promptParts;
                     const modelLabel = friendlyModelName(config.model);
@@ -306,7 +349,7 @@ export function registerStructuredToolTask(server, config) {
                         throw new Error('Unexpected state: parsed result is undefined');
                     }
                     const finalResult = (config.transformResult
-                        ? config.transformResult(inputRecord, parsed)
+                        ? config.transformResult(inputRecord, parsed, ctx)
                         : parsed);
                     const textContent = config.formatOutput
                         ? config.formatOutput(finalResult)

package/dist/schemas/inputs.js

@@ -20,57 +20,59 @@ function createBoundedString(min, max, description) {
 function createOptionalBoundedString(min, max, description) {
     return createBoundedString(min, max, description).optional();
 }
-function createLanguageSchema(description) {
-    return createOptionalBoundedString(INPUT_LIMITS.language.min, INPUT_LIMITS.language.max, description);
+const LANGUAGE_DESCRIPTION = 'Primary programming language (e.g. TypeScript, Python, Rust). Auto-infer from file extensions. Omit if multi-language.';
+const REPOSITORY_DESCRIPTION = 'Repository identifier (owner/repo). Auto-infer from git remote or directory name.';
+function createLanguageSchema() {
+    return createOptionalBoundedString(INPUT_LIMITS.language.min, INPUT_LIMITS.language.max, LANGUAGE_DESCRIPTION);
 }
 function createRepositorySchema() {
-    return createBoundedString(INPUT_LIMITS.repository.min, INPUT_LIMITS.repository.max, 'Repository identifier, e.g. org/repo.');
+    return createBoundedString(INPUT_LIMITS.repository.min, INPUT_LIMITS.repository.max, REPOSITORY_DESCRIPTION);
 }
 function createOptionalBoundedInteger(min, max, description) {
     return z.number().int().min(min).max(max).optional().describe(description);
 }
 export const FileContextSchema = z.strictObject({
-    path: createBoundedString(INPUT_LIMITS.fileContext.path.min, INPUT_LIMITS.fileContext.path.max, 'File path relative to repo root.'),
+    path: createBoundedString(INPUT_LIMITS.fileContext.path.min, INPUT_LIMITS.fileContext.path.max, 'Repo-relative path (e.g. src/utils/helpers.ts).'),
     content: createBoundedString(INPUT_LIMITS.fileContext.content.min, INPUT_LIMITS.fileContext.content.max, 'Full file content.'),
 });
 export const AnalyzePrImpactInputSchema = z.strictObject({
     repository: createRepositorySchema(),
-    language: createLanguageSchema('Primary language to bias analysis.'),
+    language: createLanguageSchema(),
 });
 export const GenerateReviewSummaryInputSchema = z.strictObject({
     repository: createRepositorySchema(),
-    language: createLanguageSchema('Primary implementation language.'),
+    language: createLanguageSchema(),
 });
 export const InspectCodeQualityInputSchema = z.strictObject({
     repository: createRepositorySchema(),
-    language: createLanguageSchema('Primary language.'),
+    language: createLanguageSchema(),
     focusAreas: z
-        .array(createBoundedString(INPUT_LIMITS.focusArea.min, INPUT_LIMITS.focusArea.max, 'Focus area tag value.'))
+        .array(createBoundedString(INPUT_LIMITS.focusArea.min, INPUT_LIMITS.focusArea.max, 'Focus tag (e.g. security, performance, bug, logic).'))
         .min(1)
         .max(INPUT_LIMITS.focusArea.maxItems)
         .optional()
-        .describe('Specific areas to inspect: security, correctness, etc.'),
-    maxFindings: createOptionalBoundedInteger(INPUT_LIMITS.maxFindings.min, INPUT_LIMITS.maxFindings.max, 'Maximum number of findings to return.'),
+        .describe('Review focus areas. Standard tags: security, performance, correctness, maintainability, concurrency. Omit for general review.'),
+    maxFindings: createOptionalBoundedInteger(INPUT_LIMITS.maxFindings.min, INPUT_LIMITS.maxFindings.max, 'Max findings (1-25). Default: 10.'),
     files: z
         .array(FileContextSchema)
         .min(1)
         .max(INPUT_LIMITS.fileContext.maxItems)
         .optional()
-        .describe('Full file contents for context-aware analysis. Provide the files changed in the diff for best results.'),
+        .describe('Full content of changed files. Highly recommended for accurate analysis. Omit if unavailable.'),
 });
 export const SuggestSearchReplaceInputSchema = z.strictObject({
-    findingTitle: createBoundedString(INPUT_LIMITS.findingTitle.min, INPUT_LIMITS.findingTitle.max, 'Short title of the finding to fix.'),
-    findingDetails: createBoundedString(INPUT_LIMITS.findingDetails.min, INPUT_LIMITS.findingDetails.max, 'Detailed explanation of the bug or risk.'),
+    findingTitle: createBoundedString(INPUT_LIMITS.findingTitle.min, INPUT_LIMITS.findingTitle.max, 'Exact finding title from inspect_code_quality.'),
+    findingDetails: createBoundedString(INPUT_LIMITS.findingDetails.min, INPUT_LIMITS.findingDetails.max, 'Exact finding explanation from inspect_code_quality.'),
 });
 export const GenerateTestPlanInputSchema = z.strictObject({
     repository: createRepositorySchema(),
-    language: createLanguageSchema('Primary language.'),
-    testFramework: createOptionalBoundedString(INPUT_LIMITS.testFramework.min, INPUT_LIMITS.testFramework.max, 'Test framework to use, e.g. jest, vitest, pytest, node:test.'),
-    maxTestCases: createOptionalBoundedInteger(INPUT_LIMITS.maxTestCases.min, INPUT_LIMITS.maxTestCases.max, 'Maximum number of test cases to return.'),
+    language: createLanguageSchema(),
+    testFramework: createOptionalBoundedString(INPUT_LIMITS.testFramework.min, INPUT_LIMITS.testFramework.max, 'Test framework (jest, vitest, pytest, node:test, junit). Auto-infer from package.json/config.'),
+    maxTestCases: createOptionalBoundedInteger(INPUT_LIMITS.maxTestCases.min, INPUT_LIMITS.maxTestCases.max, 'Max test cases (1-30). Default: 15.'),
 });
 export const AnalyzeComplexityInputSchema = z.strictObject({
-    language: createLanguageSchema('Primary language to bias analysis.'),
+    language: createLanguageSchema(),
 });
 export const DetectApiBreakingInputSchema = z.strictObject({
-    language: createLanguageSchema('Primary language to bias analysis.'),
+    language: createLanguageSchema(),
 });

package/dist/tools/analyze-complexity.js

@@ -1,5 +1,5 @@
 import { validateDiffBudget } from '../lib/diff-budget.js';
-import { createNoDiffError, getDiff } from '../lib/diff-store.js';
+import { createNoDiffError } 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';
@@ -15,7 +15,7 @@ export function registerAnalyzeComplexityTool(server) {
     registerStructuredToolTask(server, {
         name: 'analyze_time_space_complexity',
         title: 'Analyze Time & Space Complexity',
-        description: 'Analyze Big-O complexity of the cached diff changes. Call generate_diff first.',
+        description: 'Analyze Big-O complexity. Prerequisite: generate_diff. Auto-infer language.',
         inputSchema: AnalyzeComplexityInputSchema,
         fullInputSchema: AnalyzeComplexityInputSchema,
         resultSchema: AnalyzeComplexityResultSchema,
@@ -26,8 +26,8 @@ export function registerAnalyzeComplexityTool(server) {
         ...(TOOL_CONTRACT.thinkingBudget !== undefined
             ? { thinkingBudget: TOOL_CONTRACT.thinkingBudget }
             : undefined),
-        validateInput: () => {
-            const slot = getDiff();
+        validateInput: (_input, ctx) => {
+            const slot = ctx.diffSlot;
             if (!slot)
                 return createNoDiffError();
             return validateDiffBudget(slot.diff);
@@ -36,9 +36,8 @@ export function registerAnalyzeComplexityTool(server) {
             ? 'Performance degradation detected'
             : 'No degradation',
         formatOutput: (result) => `Complexity Analysis: Time=${result.timeComplexity}, Space=${result.spaceComplexity}. ${result.explanation}`,
-        buildPrompt: (input) => {
-            const slot = getDiff();
-            const diff = slot?.diff ?? '';
+        buildPrompt: (input, ctx) => {
+            const diff = ctx.diffSlot?.diff ?? '';
             const languageLine = input.language
                 ? `\nLanguage: ${input.language}`
                 : '';

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

@@ -1,6 +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 { createNoDiffError } 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';
@@ -19,7 +19,7 @@ export function registerAnalyzePrImpactTool(server) {
     registerStructuredToolTask(server, {
         name: 'analyze_pr_impact',
         title: 'Analyze PR Impact',
-        description: 'Assess the impact and risk of the cached diff. Call generate_diff first.',
+        description: 'Assess impact and risk from cached diff. Prerequisite: generate_diff. Auto-infer repo/language.',
         inputSchema: AnalyzePrImpactInputSchema,
         fullInputSchema: AnalyzePrImpactInputSchema,
         resultSchema: PrImpactResultSchema,
@@ -27,17 +27,16 @@ export function registerAnalyzePrImpactTool(server) {
         model: TOOL_CONTRACT.model,
         timeoutMs: TOOL_CONTRACT.timeoutMs,
         maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
-        validateInput: () => {
-            const slot = getDiff();
+        validateInput: (_input, ctx) => {
+            const slot = ctx.diffSlot;
             if (!slot)
                 return createNoDiffError();
             return validateDiffBudget(slot.diff);
         },
         formatOutcome: (result) => `severity: ${result.severity}`,
         formatOutput: (result) => `Impact Analysis (${result.severity}): ${result.summary}`,
-        buildPrompt: (input) => {
-            const slot = getDiff();
-            const diff = slot?.diff ?? '';
+        buildPrompt: (input, ctx) => {
+            const diff = ctx.diffSlot?.diff ?? '';
             const files = parseDiffFiles(diff);
             const { stats, summary: fileSummary } = computeDiffStatsAndSummaryFromFiles(files);
             const languageSegment = formatLanguageSegment(input.language);

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

@@ -1,5 +1,5 @@
 import { validateDiffBudget } from '../lib/diff-budget.js';
-import { createNoDiffError, getDiff } from '../lib/diff-store.js';
+import { createNoDiffError } 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';
@@ -15,7 +15,7 @@ export function registerDetectApiBreakingTool(server) {
     registerStructuredToolTask(server, {
         name: 'detect_api_breaking_changes',
         title: 'Detect API Breaking Changes',
-        description: 'Detect breaking changes to public APIs in the cached diff. Call generate_diff first.',
+        description: 'Detect breaking API changes. Prerequisite: generate_diff. Auto-infer language.',
         inputSchema: DetectApiBreakingInputSchema,
         fullInputSchema: DetectApiBreakingInputSchema,
         resultSchema: DetectApiBreakingResultSchema,
@@ -23,8 +23,8 @@ export function registerDetectApiBreakingTool(server) {
         model: TOOL_CONTRACT.model,
         timeoutMs: TOOL_CONTRACT.timeoutMs,
         maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
-        validateInput: () => {
-            const slot = getDiff();
+        validateInput: (_input, ctx) => {
+            const slot = ctx.diffSlot;
             if (!slot)
                 return createNoDiffError();
             return validateDiffBudget(slot.diff);
@@ -33,9 +33,8 @@ export function registerDetectApiBreakingTool(server) {
         formatOutput: (result) => result.hasBreakingChanges
             ? `API Breaking Changes: ${result.breakingChanges.length} found.`
             : 'No API breaking changes detected.',
-        buildPrompt: (input) => {
-            const slot = getDiff();
-            const diff = slot?.diff ?? '';
+        buildPrompt: (input, ctx) => {
+            const diff = ctx.diffSlot?.diff ?? '';
             const languageLine = input.language
                 ? `\nLanguage: ${input.language}`
                 : '';

package/dist/tools/generate-diff.js

@@ -3,6 +3,7 @@ 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 { wrapToolHandler } from '../lib/tool-factory.js';
 import { createErrorToolResponse, createToolResponse, } from '../lib/tool-response.js';
 const GIT_TIMEOUT_MS = 30_000;
 const GIT_MAX_BUFFER = 10 * 1024 * 1024; // 10 MB
@@ -29,6 +30,9 @@ export function registerGenerateDiffTool(server) {
                 .enum(['unstaged', 'staged'])
                 .describe('"unstaged": working-tree changes not yet staged. "staged": changes added to the index with git add.'),
         },
+    }, wrapToolHandler({
+        toolName: 'generate_diff',
+        progressContext: (input) => input.mode,
     }, (input) => {
         const { mode } = input;
         const args = buildGitArgs(mode);
@@ -67,5 +71,5 @@ export function registerGenerateDiffTool(server) {
                 message: summary,
             },
         }, summary);
-    });
+    }));
 }

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

@@ -1,8 +1,8 @@
 import { validateDiffBudget } from '../lib/diff-budget.js';
 import { computeDiffStatsFromFiles, parseDiffFiles, } from '../lib/diff-parser.js';
-import { createNoDiffError, getDiff } from '../lib/diff-store.js';
+import { createNoDiffError } from '../lib/diff-store.js';
 import { requireToolContract } from '../lib/tool-contracts.js';
-import { registerStructuredToolTask } from '../lib/tool-factory.js';
+import { registerStructuredToolTask, } from '../lib/tool-factory.js';
 import { GenerateReviewSummaryInputSchema } from '../schemas/inputs.js';
 import { ReviewSummaryResultSchema } from '../schemas/outputs.js';
 const ReviewSummaryModelSchema = ReviewSummaryResultSchema.omit({
@@ -17,11 +17,16 @@ Return strict JSON only.
 function formatLanguageSegment(language) {
     return language ? `\nLanguage: ${language}` : '';
 }
+function getDiffStats(ctx) {
+    const diff = ctx.diffSlot?.diff ?? '';
+    const { files, added, deleted } = computeDiffStatsFromFiles(parseDiffFiles(diff));
+    return { diff, files, added, deleted };
+}
 export function registerGenerateReviewSummaryTool(server) {
     registerStructuredToolTask(server, {
         name: 'generate_review_summary',
         title: 'Generate Review Summary',
-        description: 'Summarize the cached diff and assess high-level risk. Call generate_diff first.',
+        description: 'Summarize diff and risk level. Prerequisite: generate_diff. Auto-infer repo/language.',
         inputSchema: GenerateReviewSummaryInputSchema,
         fullInputSchema: GenerateReviewSummaryInputSchema,
         resultSchema: ReviewSummaryModelSchema,
@@ -29,39 +34,33 @@ export function registerGenerateReviewSummaryTool(server) {
         model: TOOL_CONTRACT.model,
         timeoutMs: TOOL_CONTRACT.timeoutMs,
         maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
-        validateInput: () => {
-            const slot = getDiff();
+        validateInput: (_input, ctx) => {
+            const slot = ctx.diffSlot;
             if (!slot)
                 return createNoDiffError();
             return validateDiffBudget(slot.diff);
         },
         formatOutcome: (result) => `risk: ${result.overallRisk}`,
-        transformResult: (input, result) => {
-            const slot = getDiff();
-            const diff = slot?.diff ?? '';
-            const parsedFiles = parseDiffFiles(diff);
-            const stats = computeDiffStatsFromFiles(parsedFiles);
+        transformResult: (_input, result, ctx) => {
+            const { files, added, deleted } = getDiffStats(ctx);
             return {
                 ...result,
                 stats: {
-                    filesChanged: stats.files,
-                    linesAdded: stats.added,
-                    linesRemoved: stats.deleted,
+                    filesChanged: files,
+                    linesAdded: added,
+                    linesRemoved: deleted,
                 },
             };
         },
         formatOutput: (result) => `Review Summary: ${result.summary}\nRecommendation: ${result.recommendation}`,
-        buildPrompt: (input) => {
-            const slot = getDiff();
-            const diff = slot?.diff ?? '';
-            const parsedFiles = parseDiffFiles(diff);
-            const stats = computeDiffStatsFromFiles(parsedFiles);
+        buildPrompt: (input, ctx) => {
+            const { diff, files, added, deleted } = getDiffStats(ctx);
             const languageSegment = formatLanguageSegment(input.language);
             return {
                 systemInstruction: SYSTEM_INSTRUCTION,
                 prompt: `
 Repository: ${input.repository}${languageSegment}
-Stats: ${stats.files} files, +${stats.added}, -${stats.deleted}
+Stats: ${files} files, +${added}, -${deleted}
 
 Diff:
 ${diff}

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

@@ -1,6 +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 { createNoDiffError } 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';
@@ -19,7 +19,7 @@ export function registerGenerateTestPlanTool(server) {
     registerStructuredToolTask(server, {
         name: 'generate_test_plan',
         title: 'Generate Test Plan',
-        description: 'Create a test plan covering the cached diff changes. Call generate_diff first.',
+        description: 'Generate test cases. Prerequisite: generate_diff. Auto-infer repo/language/framework.',
         inputSchema: GenerateTestPlanInputSchema,
         fullInputSchema: GenerateTestPlanInputSchema,
         resultSchema: TestPlanResultSchema,
@@ -30,8 +30,8 @@ export function registerGenerateTestPlanTool(server) {
         ...(TOOL_CONTRACT.thinkingBudget !== undefined
             ? { thinkingBudget: TOOL_CONTRACT.thinkingBudget }
             : undefined),
-        validateInput: () => {
-            const slot = getDiff();
+        validateInput: (_input, ctx) => {
+            const slot = ctx.diffSlot;
             if (!slot)
                 return createNoDiffError();
             return validateDiffBudget(slot.diff);
@@ -42,9 +42,8 @@ export function registerGenerateTestPlanTool(server) {
             const cappedTestCases = result.testCases.slice(0, input.maxTestCases ?? result.testCases.length);
             return { ...result, testCases: cappedTestCases };
         },
-        buildPrompt: (input) => {
-            const slot = getDiff();
-            const diff = slot?.diff ?? '';
+        buildPrompt: (input, ctx) => {
+            const diff = ctx.diffSlot?.diff ?? '';
             const parsedFiles = parseDiffFiles(diff);
             const { stats, paths } = computeDiffStatsAndPathsFromFiles(parsedFiles);
             const languageLine = formatOptionalLine('Language', input.language);

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

@@ -1,7 +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 { createNoDiffError } 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';
@@ -54,7 +54,7 @@ export function registerInspectCodeQualityTool(server) {
     registerStructuredToolTask(server, {
         name: 'inspect_code_quality',
         title: 'Inspect Code Quality',
-        description: 'Deep-dive code review with optional file context. Call generate_diff first.',
+        description: 'Deep code review. Prerequisite: generate_diff. Auto-infer repo/language/focus. Provide file content for best results.',
         inputSchema: InspectCodeQualityInputSchema,
         fullInputSchema: InspectCodeQualityInputSchema,
         resultSchema: CodeQualityOutputSchema,
@@ -70,8 +70,8 @@ export function registerInspectCodeQualityTool(server) {
             const fileCount = input.files?.length;
             return fileCount ? `+${fileCount} files` : '';
         },
-        validateInput: (input) => {
-            const slot = getDiff();
+        validateInput: (input, ctx) => {
+            const slot = ctx.diffSlot;
             if (!slot)
                 return createNoDiffError();
             const diffError = validateDiffBudget(slot.diff);
@@ -93,9 +93,8 @@ export function registerInspectCodeQualityTool(server) {
             const cappedFindings = capFindings(result.findings, input.maxFindings);
             return { ...result, findings: cappedFindings, totalFindings };
         },
-        buildPrompt: (input) => {
-            const slot = getDiff();
-            const diff = slot?.diff ?? '';
+        buildPrompt: (input, ctx) => {
+            const diff = ctx.diffSlot?.diff ?? '';
             const parsedFiles = parseDiffFiles(diff);
             const { summary: fileSummary } = computeDiffStatsAndSummaryFromFiles(parsedFiles);
             const fileContext = formatFileContext(input.files);

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

@@ -1,6 +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 { createNoDiffError } 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';
@@ -19,7 +19,7 @@ export function registerSuggestSearchReplaceTool(server) {
     registerStructuredToolTask(server, {
         name: 'suggest_search_replace',
         title: 'Suggest Search & Replace',
-        description: 'Generate search-and-replace blocks to fix a finding from the cached diff. Call generate_diff first.',
+        description: 'Generate fix patches. Prerequisite: inspect_code_quality findings. Pass verbatim finding title/details.',
         inputSchema: SuggestSearchReplaceInputSchema,
         fullInputSchema: SuggestSearchReplaceInputSchema,
         resultSchema: SearchReplaceResultSchema,
@@ -30,8 +30,8 @@ export function registerSuggestSearchReplaceTool(server) {
         ...(TOOL_CONTRACT.thinkingBudget !== undefined
             ? { thinkingBudget: TOOL_CONTRACT.thinkingBudget }
             : undefined),
-        validateInput: () => {
-            const slot = getDiff();
+        validateInput: (_input, ctx) => {
+            const slot = ctx.diffSlot;
             if (!slot)
                 return createNoDiffError();
             return validateDiffBudget(slot.diff);
@@ -42,9 +42,8 @@ export function registerSuggestSearchReplaceTool(server) {
             const patches = formatPatchCount(count);
             return `${result.summary}\n${patches} • Checklist: ${result.validationChecklist.join(' | ')}`;
         },
-        buildPrompt: (input) => {
-            const slot = getDiff();
-            const diff = slot?.diff ?? '';
+        buildPrompt: (input, ctx) => {
+            const diff = ctx.diffSlot?.diff ?? '';
             const files = parseDiffFiles(diff);
             const paths = extractChangedPathsFromFiles(files);
             return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@j0hanz/code-review-analyst-mcp",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "mcpName": "io.github.j0hanz/code-review-analyst",
   "description": "Gemini-powered MCP server for code review analysis.",
   "type": "module",