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

package/dist/schemas/inputs.d.ts

@@ -4,17 +4,14 @@ export declare const FileContextSchema: z.ZodObject<{
     content: z.ZodString;
 }, z.core.$strict>;
 export declare const AnalyzePrImpactInputSchema: z.ZodObject<{
-    diff: z.ZodString;
     repository: z.ZodString;
     language: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export declare const GenerateReviewSummaryInputSchema: z.ZodObject<{
-    diff: z.ZodString;
     repository: z.ZodString;
     language: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export declare const InspectCodeQualityInputSchema: z.ZodObject<{
-    diff: z.ZodString;
     repository: z.ZodString;
     language: z.ZodOptional<z.ZodString>;
     focusAreas: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -25,22 +22,18 @@ export declare const InspectCodeQualityInputSchema: z.ZodObject<{
     }, z.core.$strict>>>;
 }, z.core.$strict>;
 export declare const SuggestSearchReplaceInputSchema: z.ZodObject<{
-    diff: z.ZodString;
     findingTitle: z.ZodString;
     findingDetails: z.ZodString;
 }, z.core.$strict>;
 export declare const GenerateTestPlanInputSchema: z.ZodObject<{
-    diff: z.ZodString;
     repository: z.ZodString;
     language: z.ZodOptional<z.ZodString>;
     testFramework: z.ZodOptional<z.ZodString>;
     maxTestCases: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
 export declare const AnalyzeComplexityInputSchema: z.ZodObject<{
-    diff: z.ZodString;
     language: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export declare const DetectApiBreakingInputSchema: z.ZodObject<{
-    diff: z.ZodString;
     language: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;

package/dist/schemas/inputs.js

@@ -1,6 +1,5 @@
 import { z } from 'zod';
 const INPUT_LIMITS = {
-    diff: { min: 10 },
     repository: { min: 1, max: 200 },
     language: { min: 2, max: 32 },
     fileContext: {
@@ -21,70 +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);
-}
-function createDiffSchema(description) {
-    return z
-        .string()
-        .min(INPUT_LIMITS.diff.min)
-        .describe(`${description} Budget is enforced at runtime via MAX_DIFF_CHARS (default 120,000 chars).`);
+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({
-    diff: createDiffSchema('Unified diff text for the PR or commit.'),
     repository: createRepositorySchema(),
-    language: createLanguageSchema('Primary language to bias analysis.'),
+    language: createLanguageSchema(),
 });
 export const GenerateReviewSummaryInputSchema = z.strictObject({
-    diff: createDiffSchema('Unified diff text for one PR or commit.'),
     repository: createRepositorySchema(),
-    language: createLanguageSchema('Primary implementation language.'),
+    language: createLanguageSchema(),
 });
 export const InspectCodeQualityInputSchema = z.strictObject({
-    diff: createDiffSchema('Unified diff text for in-depth analysis.'),
     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({
-    diff: createDiffSchema('Unified diff that contains the issue to fix.'),
-    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({
-    diff: createDiffSchema('Unified diff to generate tests for.'),
     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({
-    diff: createDiffSchema('Unified diff to analyze for time and space complexity.'),
-    language: createLanguageSchema('Primary language to bias analysis.'),
+    language: createLanguageSchema(),
 });
 export const DetectApiBreakingInputSchema = z.strictObject({
-    diff: createDiffSchema('Unified diff to scan for API breaking changes.'),
-    language: createLanguageSchema('Primary language to bias analysis.'),
+    language: createLanguageSchema(),
 });

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 } 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. Prerequisite: generate_diff. Auto-infer language.',
         inputSchema: AnalyzeComplexityInputSchema,
         fullInputSchema: AnalyzeComplexityInputSchema,
         resultSchema: AnalyzeComplexityResultSchema,
@@ -32,14 +26,25 @@ export function registerAnalyzeComplexityTool(server) {
         ...(TOOL_CONTRACT.thinkingBudget !== undefined
             ? { thinkingBudget: TOOL_CONTRACT.thinkingBudget }
             : undefined),
-        validateInput: (input) => validateDiffBudget(input.diff),
+        validateInput: (_input, ctx) => {
+            const slot = ctx.diffSlot;
+            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, ctx) => {
+            const diff = ctx.diffSlot?.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 } 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 impact and risk from cached diff. Prerequisite: generate_diff. Auto-infer repo/language.',
         inputSchema: AnalyzePrImpactInputSchema,
         fullInputSchema: AnalyzePrImpactInputSchema,
         resultSchema: PrImpactResultSchema,
@@ -40,12 +27,31 @@ export function registerAnalyzePrImpactTool(server) {
         model: TOOL_CONTRACT.model,
         timeoutMs: TOOL_CONTRACT.timeoutMs,
         maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
-        validateInput: (input) => validateDiffBudget(input.diff),
+        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) => ({
-            systemInstruction: SYSTEM_INSTRUCTION,
-            prompt: buildAnalyzePrImpactPrompt(input),
-        }),
+        buildPrompt: (input, ctx) => {
+            const diff = ctx.diffSlot?.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 } 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 API changes. Prerequisite: generate_diff. Auto-infer language.',
         inputSchema: DetectApiBreakingInputSchema,
         fullInputSchema: DetectApiBreakingInputSchema,
         resultSchema: DetectApiBreakingResultSchema,
@@ -29,14 +23,25 @@ export function registerDetectApiBreakingTool(server) {
         model: TOOL_CONTRACT.model,
         timeoutMs: TOOL_CONTRACT.timeoutMs,
         maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
-        validateInput: (input) => validateDiffBudget(input.diff),
+        validateInput: (_input, ctx) => {
+            const slot = ctx.diffSlot;
+            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, ctx) => {
+            const diff = ctx.diffSlot?.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,7 +1,8 @@
 import { validateDiffBudget } from '../lib/diff-budget.js';
 import { computeDiffStatsFromFiles, parseDiffFiles, } from '../lib/diff-parser.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({
@@ -13,36 +14,19 @@ 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}
-`;
+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 a pull request diff and assess high-level risk.',
+        description: 'Summarize diff and risk level. Prerequisite: generate_diff. Auto-infer repo/language.',
         inputSchema: GenerateReviewSummaryInputSchema,
         fullInputSchema: GenerateReviewSummaryInputSchema,
         resultSchema: ReviewSummaryModelSchema,
@@ -50,24 +34,38 @@ export function registerGenerateReviewSummaryTool(server) {
         model: TOOL_CONTRACT.model,
         timeoutMs: TOOL_CONTRACT.timeoutMs,
         maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
-        validateInput: (input) => validateDiffBudget(input.diff),
+        validateInput: (_input, ctx) => {
+            const slot = ctx.diffSlot;
+            if (!slot)
+                return createNoDiffError();
+            return validateDiffBudget(slot.diff);
+        },
         formatOutcome: (result) => `risk: ${result.overallRisk}`,
-        transformResult: (input, result) => {
-            const stats = getCachedStats(input);
-            statsCache.delete(input);
+        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) => ({
-            systemInstruction: SYSTEM_INSTRUCTION,
-            prompt: buildReviewSummaryPrompt(input),
-        }),
+        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: ${files} files, +${added}, -${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 } 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: 'Generate test cases. Prerequisite: generate_diff. Auto-infer repo/language/framework.',
         inputSchema: GenerateTestPlanInputSchema,
         fullInputSchema: GenerateTestPlanInputSchema,
         resultSchema: TestPlanResultSchema,
@@ -44,19 +30,36 @@ export function registerGenerateTestPlanTool(server) {
         ...(TOOL_CONTRACT.thinkingBudget !== undefined
             ? { thinkingBudget: TOOL_CONTRACT.thinkingBudget }
             : undefined),
-        validateInput: (input) => validateDiffBudget(input.diff),
+        validateInput: (_input, ctx) => {
+            const slot = ctx.diffSlot;
+            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, ctx) => {
+            const diff = ctx.diffSlot?.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,