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

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,14 +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<{
+    language: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const DetectApiBreakingInputSchema: z.ZodObject<{
+    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: {
@@ -24,29 +23,26 @@ function createOptionalBoundedString(min, max, description) {
 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).`);
+function createRepositorySchema() {
+    return createBoundedString(INPUT_LIMITS.repository.min, INPUT_LIMITS.repository.max, 'Repository identifier, e.g. org/repo.');
+}
+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.'),
     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: createBoundedString(INPUT_LIMITS.repository.min, INPUT_LIMITS.repository.max, 'Repository identifier, e.g. org/repo.'),
+    repository: createRepositorySchema(),
     language: createLanguageSchema('Primary language to bias analysis.'),
 });
 export const GenerateReviewSummaryInputSchema = z.strictObject({
-    diff: createDiffSchema('Unified diff text for one PR or commit.'),
-    repository: createBoundedString(INPUT_LIMITS.repository.min, INPUT_LIMITS.repository.max, 'Repository identifier, e.g. org/repo.'),
+    repository: createRepositorySchema(),
     language: createLanguageSchema('Primary implementation language.'),
 });
 export const InspectCodeQualityInputSchema = z.strictObject({
-    diff: createDiffSchema('Unified diff text for in-depth analysis.'),
-    repository: createBoundedString(INPUT_LIMITS.repository.min, INPUT_LIMITS.repository.max, 'Repository identifier, e.g. org/repo.'),
+    repository: createRepositorySchema(),
     language: createLanguageSchema('Primary language.'),
     focusAreas: z
         .array(createBoundedString(INPUT_LIMITS.focusArea.min, INPUT_LIMITS.focusArea.max, 'Focus area tag value.'))
@@ -54,13 +50,7 @@ export const InspectCodeQualityInputSchema = z.strictObject({
         .max(INPUT_LIMITS.focusArea.maxItems)
         .optional()
         .describe('Specific areas to inspect: security, correctness, etc.'),
-    maxFindings: z
-        .number()
-        .int()
-        .min(1)
-        .max(25)
-        .optional()
-        .describe('Maximum number of findings to return.'),
+    maxFindings: createOptionalBoundedInteger(INPUT_LIMITS.maxFindings.min, INPUT_LIMITS.maxFindings.max, 'Maximum number of findings to return.'),
     files: z
         .array(FileContextSchema)
         .min(1)
@@ -69,20 +59,18 @@ export const InspectCodeQualityInputSchema = z.strictObject({
         .describe('Full file contents for context-aware analysis. Provide the files changed in the diff for best results.'),
 });
 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.'),
 });
 export const GenerateTestPlanInputSchema = z.strictObject({
-    diff: createDiffSchema('Unified diff to generate tests for.'),
-    repository: createBoundedString(INPUT_LIMITS.repository.min, INPUT_LIMITS.repository.max, 'Repository identifier, e.g. org/repo.'),
+    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: z
-        .number()
-        .int()
-        .min(INPUT_LIMITS.maxTestCases.min)
-        .max(INPUT_LIMITS.maxTestCases.max)
-        .optional()
-        .describe('Maximum number of test cases to return.'),
+    maxTestCases: createOptionalBoundedInteger(INPUT_LIMITS.maxTestCases.min, INPUT_LIMITS.maxTestCases.max, 'Maximum number of test cases to return.'),
+});
+export const AnalyzeComplexityInputSchema = z.strictObject({
+    language: createLanguageSchema('Primary language to bias analysis.'),
+});
+export const DetectApiBreakingInputSchema = z.strictObject({
+    language: createLanguageSchema('Primary language to bias analysis.'),
 });

package/dist/schemas/outputs.d.ts

@@ -98,6 +98,7 @@ export declare const CodeQualityResultSchema: z.ZodObject<{
     contextualInsights: z.ZodArray<z.ZodString>;
 }, z.core.$strict>;
 export declare const CodeQualityOutputSchema: z.ZodObject<{
+    totalFindings: z.ZodOptional<z.ZodNumber>;
     summary: z.ZodString;
     overallRisk: z.ZodEnum<{
         low: "low";
@@ -120,7 +121,6 @@ export declare const CodeQualityOutputSchema: z.ZodObject<{
     }, z.core.$strict>>;
     testsNeeded: z.ZodArray<z.ZodString>;
     contextualInsights: z.ZodArray<z.ZodString>;
-    totalFindings: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export declare const SearchReplaceBlockSchema: z.ZodObject<{
     file: z.ZodString;
@@ -180,3 +180,19 @@ export declare const TestPlanResultSchema: z.ZodObject<{
     }, z.core.$strict>>;
     coverageSummary: z.ZodString;
 }, z.core.$strict>;
+export declare const AnalyzeComplexityResultSchema: z.ZodObject<{
+    timeComplexity: z.ZodString;
+    spaceComplexity: z.ZodString;
+    explanation: z.ZodString;
+    potentialBottlenecks: z.ZodArray<z.ZodString>;
+    isDegradation: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const DetectApiBreakingResultSchema: z.ZodObject<{
+    hasBreakingChanges: z.ZodBoolean;
+    breakingChanges: z.ZodArray<z.ZodObject<{
+        element: z.ZodString;
+        natureOfChange: z.ZodString;
+        consumerImpact: z.ZodString;
+        suggestedMitigation: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;

package/dist/schemas/outputs.js

@@ -12,16 +12,30 @@ const OUTPUT_LIMITS = {
         findingsMax: 50,
         testsNeeded: { minItems: 0, maxItems: 20, itemMin: 1, itemMax: 300 },
     },
-    riskScoreResult: {
-        score: { min: 0, max: 100 },
-        rationale: { minItems: 1, maxItems: 20, itemMin: 1, itemMax: 500 },
+    complexity: {
+        timeComplexity: { min: 1, max: 200 },
+        spaceComplexity: { min: 1, max: 200 },
+        explanation: { min: 1, max: 2_000 },
+        bottleneck: { min: 1, max: 500, maxItems: 10 },
     },
-    patchSuggestionResult: {
-        summary: { min: 1, max: 1_000 },
-        patch: { min: 1, max: 60_000 },
-        checklist: { minItems: 1, maxItems: 20, itemMin: 1, itemMax: 300 },
+    apiBreaking: {
+        element: { min: 1, max: 300 },
+        natureOfChange: { min: 1, max: 500 },
+        consumerImpact: { min: 1, max: 500 },
+        suggestedMitigation: { min: 1, max: 500 },
+        maxItems: 20,
     },
 };
+const QUALITY_RISK_LEVELS = ['low', 'medium', 'high', 'critical'];
+const MERGE_RISK_LEVELS = ['low', 'medium', 'high'];
+const ERROR_KINDS = [
+    'validation',
+    'budget',
+    'upstream',
+    'timeout',
+    'cancelled',
+    'internal',
+];
 function createBoundedString(min, max, description) {
     return z.string().min(min).max(max).describe(description);
 }
@@ -32,6 +46,22 @@ function createBoundedStringArray(itemMin, itemMax, minItems, maxItems, descript
         .max(maxItems)
         .describe(description);
 }
+function createReviewSummarySchema(description) {
+    return z
+        .string()
+        .min(OUTPUT_LIMITS.reviewDiffResult.summary.min)
+        .max(OUTPUT_LIMITS.reviewDiffResult.summary.max)
+        .describe(description);
+}
+const reviewFindingSeveritySchema = z
+    .enum(QUALITY_RISK_LEVELS)
+    .describe('Severity for this issue.');
+const qualityRiskSchema = z
+    .enum(QUALITY_RISK_LEVELS)
+    .describe('Overall risk with full context.');
+const mergeRiskSchema = z
+    .enum(MERGE_RISK_LEVELS)
+    .describe('High-level merge risk.');
 export const DefaultOutputSchema = z.strictObject({
     ok: z.boolean().describe('Whether the tool completed successfully.'),
     result: z.unknown().optional().describe('Successful result payload.'),
@@ -44,14 +74,7 @@ export const DefaultOutputSchema = z.strictObject({
             .optional()
             .describe('Whether the client should retry this request.'),
         kind: z
-            .enum([
-            'validation',
-            'budget',
-            'upstream',
-            'timeout',
-            'cancelled',
-            'internal',
-        ])
+            .enum(ERROR_KINDS)
             .optional()
             .describe('Machine-readable error category.'),
     })
@@ -59,9 +82,7 @@ export const DefaultOutputSchema = z.strictObject({
         .describe('Error payload when ok is false.'),
 });
 export const ReviewFindingSchema = z.strictObject({
-    severity: z
-        .enum(['low', 'medium', 'high', 'critical'])
-        .describe('Severity for this issue.'),
+    severity: reviewFindingSeveritySchema,
     file: z
         .string()
         .min(1)
@@ -75,13 +96,22 @@ export const ReviewFindingSchema = z.strictObject({
         .nullable()
         .describe('1-based line number when known, otherwise null.'),
     title: createBoundedString(OUTPUT_LIMITS.reviewFinding.title.min, OUTPUT_LIMITS.reviewFinding.title.max, 'Short finding title.'),
-    explanation: createBoundedString(OUTPUT_LIMITS.reviewFinding.text.min, OUTPUT_LIMITS.reviewFinding.text.max, 'Why this issue matters.'),
-    recommendation: createBoundedString(OUTPUT_LIMITS.reviewFinding.text.min, OUTPUT_LIMITS.reviewFinding.text.max, 'Concrete fix recommendation.'),
+    explanation: createBoundedString(OUTPUT_LIMITS.reviewFinding.text.min, OUTPUT_LIMITS.reviewFinding.text.max, 'What the issue is and its runtime, security, or correctness impact.'),
+    recommendation: createBoundedString(OUTPUT_LIMITS.reviewFinding.text.min, OUTPUT_LIMITS.reviewFinding.text.max, 'Concrete fix - name the exact code, function, or pattern to change.'),
 });
+const CODE_QUALITY_SHARED_FIELDS = {
+    summary: createReviewSummarySchema('Deep-dive review summary.'),
+    overallRisk: qualityRiskSchema,
+    findings: z
+        .array(ReviewFindingSchema)
+        .min(0)
+        .max(30)
+        .describe('Findings ordered by severity, highest first.'),
+    testsNeeded: createBoundedStringArray(1, 300, 0, 12, 'Test cases needed to validate this change.'),
+    contextualInsights: createBoundedStringArray(1, 500, 0, 5, 'Cross-file insights only discoverable from the full file context. Omit when no file context was provided.'),
+};
 export const PrImpactResultSchema = z.strictObject({
-    severity: z
-        .enum(['low', 'medium', 'high', 'critical'])
-        .describe('Overall impact severity.'),
+    severity: z.enum(QUALITY_RISK_LEVELS).describe('Overall impact severity.'),
     categories: z
         .array(z.enum([
         'breaking_change',
@@ -106,10 +136,8 @@ export const PrImpactResultSchema = z.strictObject({
         .describe('Estimated difficulty to revert this change.'),
 });
 export const ReviewSummaryResultSchema = z.strictObject({
-    summary: z.string().min(1).max(2000).describe('Human-readable PR summary.'),
-    overallRisk: z
-        .enum(['low', 'medium', 'high'])
-        .describe('High-level merge risk.'),
+    summary: createReviewSummarySchema('Human-readable PR summary.'),
+    overallRisk: mergeRiskSchema,
     keyChanges: createBoundedStringArray(1, 300, 1, 15, 'Most important changes, ordered by significance.'),
     recommendation: z
         .string()
@@ -129,30 +157,10 @@ export const ReviewSummaryResultSchema = z.strictObject({
         .describe('Change statistics (computed from diff before Gemini call).'),
 });
 export const CodeQualityResultSchema = z.strictObject({
-    summary: z.string().min(1).max(2000).describe('Deep-dive review summary.'),
-    overallRisk: z
-        .enum(['low', 'medium', 'high', 'critical'])
-        .describe('Overall risk with full context.'),
-    findings: z
-        .array(ReviewFindingSchema)
-        .min(0)
-        .max(30)
-        .describe('Findings ordered by severity, highest first.'),
-    testsNeeded: createBoundedStringArray(1, 300, 0, 12, 'Test cases needed to validate this change.'),
-    contextualInsights: createBoundedStringArray(1, 500, 0, 5, 'Insights only possible with full file context that diff alone cannot reveal.'),
+    ...CODE_QUALITY_SHARED_FIELDS,
 });
 export const CodeQualityOutputSchema = z.object({
-    summary: z.string().min(1).max(2000).describe('Deep-dive review summary.'),
-    overallRisk: z
-        .enum(['low', 'medium', 'high', 'critical'])
-        .describe('Overall risk with full context.'),
-    findings: z
-        .array(ReviewFindingSchema)
-        .min(0)
-        .max(30)
-        .describe('Findings ordered by severity, highest first.'),
-    testsNeeded: createBoundedStringArray(1, 300, 0, 12, 'Test cases needed to validate this change.'),
-    contextualInsights: createBoundedStringArray(1, 500, 0, 5, 'Insights only possible with full file context that diff alone cannot reveal.'),
+    ...CODE_QUALITY_SHARED_FIELDS,
     totalFindings: z
         .number()
         .int()
@@ -166,17 +174,17 @@ export const SearchReplaceBlockSchema = z.strictObject({
         .string()
         .min(1)
         .max(5000)
-        .describe('Exact verbatim text to find in the file.'),
+        .describe('Verbatim source text to find - character-exact including all whitespace and indentation.'),
     replace: z
         .string()
         .min(0)
         .max(5000)
-        .describe('Replacement text (empty string = deletion).'),
+        .describe('Replacement text. Use empty string to delete.'),
     explanation: z
         .string()
         .min(1)
         .max(500)
-        .describe('Why this change fixes the finding.'),
+        .describe('Why this patch fixes the finding.'),
 });
 export const SearchReplaceResultSchema = z.strictObject({
     summary: z.string().min(1).max(1000).describe('What the fix accomplishes.'),
@@ -227,3 +235,27 @@ export const TestPlanResultSchema = z.strictObject({
         .max(500)
         .describe('Summary of coverage gaps this plan addresses.'),
 });
+export const AnalyzeComplexityResultSchema = z.strictObject({
+    timeComplexity: createBoundedString(OUTPUT_LIMITS.complexity.timeComplexity.min, OUTPUT_LIMITS.complexity.timeComplexity.max, 'Big-O time complexity of the changed code (e.g., O(n log n)).'),
+    spaceComplexity: createBoundedString(OUTPUT_LIMITS.complexity.spaceComplexity.min, OUTPUT_LIMITS.complexity.spaceComplexity.max, 'Big-O space complexity of the changed code (e.g., O(n)).'),
+    explanation: createBoundedString(OUTPUT_LIMITS.complexity.explanation.min, OUTPUT_LIMITS.complexity.explanation.max, 'Detailed explanation of the complexity analysis, including key factors such as loop nesting and recursive calls.'),
+    potentialBottlenecks: createBoundedStringArray(OUTPUT_LIMITS.complexity.bottleneck.min, OUTPUT_LIMITS.complexity.bottleneck.max, 0, OUTPUT_LIMITS.complexity.bottleneck.maxItems, 'Potential performance bottlenecks identified in the change.'),
+    isDegradation: z
+        .boolean()
+        .describe('True if the change introduces a performance degradation compared to the original code.'),
+});
+export const DetectApiBreakingResultSchema = z.strictObject({
+    hasBreakingChanges: z
+        .boolean()
+        .describe('True if any breaking changes were detected.'),
+    breakingChanges: z
+        .array(z.strictObject({
+        element: createBoundedString(OUTPUT_LIMITS.apiBreaking.element.min, OUTPUT_LIMITS.apiBreaking.element.max, 'Name of the API element that changed (e.g., function signature, interface field, exported constant).'),
+        natureOfChange: createBoundedString(OUTPUT_LIMITS.apiBreaking.natureOfChange.min, OUTPUT_LIMITS.apiBreaking.natureOfChange.max, 'What changed and why it is breaking (e.g., removed parameter, changed return type, renamed export).'),
+        consumerImpact: createBoundedString(OUTPUT_LIMITS.apiBreaking.consumerImpact.min, OUTPUT_LIMITS.apiBreaking.consumerImpact.max, 'How existing consumers will be affected by this change.'),
+        suggestedMitigation: createBoundedString(OUTPUT_LIMITS.apiBreaking.suggestedMitigation.min, OUTPUT_LIMITS.apiBreaking.suggestedMitigation.max, 'Recommended mitigation strategy for consumers impacted by this breaking change.'),
+    }))
+        .min(0)
+        .max(OUTPUT_LIMITS.apiBreaking.maxItems)
+        .describe('List of breaking changes detected. Empty when hasBreakingChanges is false.'),
+});

package/dist/server.js

@@ -2,22 +2,20 @@ 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 { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
+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';
+import { buildServerInstructions } from './resources/instructions.js';
 import { registerAllTools } from './tools/index.js';
 const SERVER_NAME = 'code-review-analyst';
-const INSTRUCTIONS_FILENAME = 'instructions.md';
-const INSTRUCTIONS_FALLBACK = '(Instructions failed to load)';
 const UTF8_ENCODING = 'utf8';
-const CURRENT_DIR = dirname(fileURLToPath(import.meta.url));
-const INSTRUCTIONS_PATH = join(CURRENT_DIR, INSTRUCTIONS_FILENAME);
+const PACKAGE_VERSION_FIELD = 'version';
+const VERSION_FIELD_ERROR = 'missing or invalid version field';
 const SERVER_CAPABILITIES = {
     logging: {},
     completions: {},
-    resources: {},
+    resources: { subscribe: true },
     tools: {},
     tasks: {
         list: {},
@@ -32,22 +30,27 @@ const SERVER_CAPABILITIES = {
 function isPackageJsonMetadata(value) {
     return (typeof value === 'object' &&
         value !== null &&
-        'version' in value &&
+        PACKAGE_VERSION_FIELD in value &&
         typeof value.version === 'string' &&
         value.version.trim().length > 0);
 }
 function parsePackageJson(packageJson, packageJsonPath) {
-    let parsed;
+    const parsed = parseJsonText(packageJson, packageJsonPath);
+    ensurePackageJsonMetadata(parsed, packageJsonPath);
+    return parsed;
+}
+function parseJsonText(jsonText, sourcePath) {
     try {
-        parsed = JSON.parse(packageJson);
+        return JSON.parse(jsonText);
     }
     catch (error) {
-        throw new Error(`Invalid JSON in ${packageJsonPath}: ${getErrorMessage(error)}`);
+        throw new Error(`Invalid JSON in ${sourcePath}: ${getErrorMessage(error)}`);
     }
-    if (!isPackageJsonMetadata(parsed)) {
-        throw new Error(`Invalid package.json at ${packageJsonPath}: missing or invalid version field`);
+}
+function ensurePackageJsonMetadata(metadata, packageJsonPath) {
+    if (!isPackageJsonMetadata(metadata)) {
+        throw new Error(`Invalid package.json at ${packageJsonPath}: ${VERSION_FIELD_ERROR}`);
     }
-    return parsed;
 }
 function readUtf8File(path) {
     try {
@@ -66,19 +69,9 @@ function loadVersion() {
     return parsePackageJson(packageJsonText, packageJsonPath).version;
 }
 const SERVER_VERSION = loadVersion();
-function loadInstructions() {
-    try {
-        return readUtf8File(INSTRUCTIONS_PATH);
-    }
-    catch (error) {
-        process.emitWarning(`Failed to load ${INSTRUCTIONS_FILENAME}: ${getErrorMessage(error)}`);
-        return INSTRUCTIONS_FALLBACK;
-    }
-}
-const SERVER_INSTRUCTIONS = loadInstructions();
-export function createServer() {
-    const taskStore = new InMemoryTaskStore();
-    const server = new McpServer({
+const SERVER_INSTRUCTIONS = buildServerInstructions();
+function createMcpServer(taskStore) {
+    return new McpServer({
         name: SERVER_NAME,
         version: SERVER_VERSION,
     }, {
@@ -86,9 +79,17 @@ export function createServer() {
         taskStore,
         capabilities: SERVER_CAPABILITIES,
     });
+}
+function registerServerCapabilities(server) {
+    initDiffStore(server);
     registerAllTools(server);
     registerAllResources(server, SERVER_INSTRUCTIONS);
     registerAllPrompts(server, SERVER_INSTRUCTIONS);
+}
+export function createServer() {
+    const taskStore = new InMemoryTaskStore();
+    const server = createMcpServer(taskStore);
+    registerServerCapabilities(server);
     const shutdown = async () => {
         await server.close();
         taskStore.cleanup();

package/dist/tools/analyze-complexity.d.ts

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

package/dist/tools/analyze-complexity.js

@@ -0,0 +1,51 @@
+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';
+import { AnalyzeComplexityResultSchema } from '../schemas/outputs.js';
+const SYSTEM_INSTRUCTION = `
+You are an algorithm complexity analyst. Analyze the diff to identify Big-O time and space complexity for added or modified functions and algorithms.
+Detect if the change introduces a performance degradation compared to the original code.
+Identify potential bottlenecks arising from loop nesting, recursive calls, and auxiliary data structure usage.
+Return strict JSON only.
+`;
+const TOOL_CONTRACT = requireToolContract('analyze_time_space_complexity');
+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.',
+        inputSchema: AnalyzeComplexityInputSchema,
+        fullInputSchema: AnalyzeComplexityInputSchema,
+        resultSchema: AnalyzeComplexityResultSchema,
+        errorCode: 'E_ANALYZE_COMPLEXITY',
+        model: TOOL_CONTRACT.model,
+        timeoutMs: TOOL_CONTRACT.timeoutMs,
+        maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
+        ...(TOOL_CONTRACT.thinkingBudget !== undefined
+            ? { thinkingBudget: TOOL_CONTRACT.thinkingBudget }
+            : undefined),
+        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) => {
+            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,46 +1,58 @@
 import { validateDiffBudget } from '../lib/diff-budget.js';
 import { computeDiffStatsAndSummaryFromFiles, parseDiffFiles, } from '../lib/diff-parser.js';
-import { DEFAULT_LANGUAGE, FLASH_MODEL } from '../lib/model-config.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';
 import { PrImpactResultSchema } from '../schemas/outputs.js';
 const SYSTEM_INSTRUCTION = `
-You are a technical change analyst.
-Your goal is to identify observable facts about what changed and their downstream effects.
-Analyze the provided Unified Diff and determine its impact severity and categories.
-Focus on breaking changes, API modifications, and rollback complexity.
+You are a technical change analyst. Analyze the diff for objective, evidence-based impact assessment.
+Classify severity, categories, breaking changes, affected areas, and rollback complexity strictly from diff evidence.
+Never infer behavior not visible in the diff.
 Return strict JSON only.
 `;
+const TOOL_CONTRACT = requireToolContract('analyze_pr_impact');
+function formatLanguageSegment(language) {
+    return language ? `\nLanguage: ${language}` : '';
+}
 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,
         errorCode: 'E_ANALYZE_IMPACT',
-        model: FLASH_MODEL,
-        validateInput: (input) => validateDiffBudget(input.diff),
-        formatOutcome: (result) => `severity: ${result.severity}`,
-        formatOutput: (result) => {
-            return `Impact Analysis (${result.severity}): ${result.summary}`;
+        model: TOOL_CONTRACT.model,
+        timeoutMs: TOOL_CONTRACT.timeoutMs,
+        maxOutputTokens: TOOL_CONTRACT.maxOutputTokens,
+        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) => {
-            const files = parseDiffFiles(input.diff);
-            const insights = computeDiffStatsAndSummaryFromFiles(files);
-            const { stats, summary: fileSummary } = insights;
-            const prompt = `
-Repository: ${input.repository}
-Language: ${input.language ?? DEFAULT_LANGUAGE}
+            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:
-${input.diff}
-`;
-            return { systemInstruction: SYSTEM_INSTRUCTION, prompt };
+${diff}
+`,
+            };
         },
     });
 }

package/dist/tools/detect-api-breaking.d.ts

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