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

package/dist/schemas/inputs.d.ts

@@ -1,26 +1,38 @@
 import { z } from 'zod';
-export declare const ReviewDiffInputSchema: z.ZodObject<{
+export declare const FileContextSchema: z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strict>;
+export declare const AnalyzePrImpactInputSchema: z.ZodObject<{
     diff: z.ZodString;
     repository: z.ZodString;
     language: z.ZodOptional<z.ZodString>;
-    focusAreas: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    maxFindings: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
-export declare const RiskScoreInputSchema: z.ZodObject<{
+export declare const GenerateReviewSummaryInputSchema: z.ZodObject<{
     diff: z.ZodString;
-    deploymentCriticality: z.ZodOptional<z.ZodEnum<{
-        low: "low";
-        medium: "medium";
-        high: "high";
-    }>>;
+    repository: z.ZodString;
+    language: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
-export declare const SuggestPatchInputSchema: z.ZodObject<{
+export declare const InspectCodeQualityInputSchema: z.ZodObject<{
+    diff: z.ZodString;
+    repository: z.ZodString;
+    language: z.ZodOptional<z.ZodString>;
+    focusAreas: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    maxFindings: z.ZodOptional<z.ZodNumber>;
+    files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export declare const SuggestSearchReplaceInputSchema: z.ZodObject<{
     diff: z.ZodString;
     findingTitle: z.ZodString;
     findingDetails: z.ZodString;
-    patchStyle: z.ZodOptional<z.ZodEnum<{
-        minimal: "minimal";
-        balanced: "balanced";
-        defensive: "defensive";
-    }>>;
+}, 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>;

package/dist/schemas/inputs.js

@@ -1,50 +1,88 @@
 import { z } from 'zod';
 const INPUT_LIMITS = {
-    diff: { min: 10, max: 400_000 },
+    diff: { min: 10 },
     repository: { min: 1, max: 200 },
     language: { min: 2, max: 32 },
+    fileContext: {
+        path: { min: 1, max: 500 },
+        content: { min: 0, max: 100_000 },
+        maxItems: 20,
+    },
     focusArea: { min: 2, max: 80, maxItems: 12 },
     maxFindings: { min: 1, max: 25 },
     findingTitle: { min: 3, max: 160 },
     findingDetails: { min: 10, max: 3_000 },
+    testFramework: { min: 1, max: 50 },
+    maxTestCases: { min: 1, max: 30 },
 };
 function createBoundedString(min, max, description) {
     return z.string().min(min).max(max).describe(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 createBoundedString(INPUT_LIMITS.diff.min, INPUT_LIMITS.diff.max, description);
+    return z
+        .string()
+        .min(INPUT_LIMITS.diff.min)
+        .describe(`${description} Budget is enforced at runtime via MAX_DIFF_CHARS (default 120,000 chars).`);
 }
-export const ReviewDiffInputSchema = z.strictObject({
+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.'),
+    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, for example org/repo.'),
-    language: createBoundedString(INPUT_LIMITS.language.min, INPUT_LIMITS.language.max, 'Primary implementation language to bias review depth.').optional(),
+    repository: createBoundedString(INPUT_LIMITS.repository.min, INPUT_LIMITS.repository.max, 'Repository identifier, e.g. org/repo.'),
+    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.'),
+    language: createLanguageSchema('Primary language.'),
     focusAreas: z
-        .array(createBoundedString(INPUT_LIMITS.focusArea.min, INPUT_LIMITS.focusArea.max, 'Specific area to inspect, for example security or tests.'))
+        .array(createBoundedString(INPUT_LIMITS.focusArea.min, INPUT_LIMITS.focusArea.max, 'Focus area tag value.'))
         .min(1)
         .max(INPUT_LIMITS.focusArea.maxItems)
         .optional()
-        .describe('Optional list of priorities for this review pass.'),
+        .describe('Specific areas to inspect: security, correctness, etc.'),
     maxFindings: z
         .number()
         .int()
-        .min(INPUT_LIMITS.maxFindings.min)
-        .max(INPUT_LIMITS.maxFindings.max)
+        .min(1)
+        .max(25)
         .optional()
         .describe('Maximum number of findings to return.'),
-});
-export const RiskScoreInputSchema = z.strictObject({
-    diff: createDiffSchema('Unified diff text to analyze for release risk.'),
-    deploymentCriticality: z
-        .enum(['low', 'medium', 'high'])
+    files: z
+        .array(FileContextSchema)
+        .min(1)
+        .max(INPUT_LIMITS.fileContext.maxItems)
         .optional()
-        .describe('How sensitive the target system is to regressions.'),
+        .describe('Full file contents for context-aware analysis. Provide the files changed in the diff for best results.'),
 });
-export const SuggestPatchInputSchema = z.strictObject({
-    diff: createDiffSchema('Unified diff text that contains the issue to patch.'),
-    findingTitle: createBoundedString(INPUT_LIMITS.findingTitle.min, INPUT_LIMITS.findingTitle.max, 'Short title of the finding that needs a patch.'),
+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.'),
-    patchStyle: z
-        .enum(['minimal', 'balanced', 'defensive'])
+});
+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.'),
+    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('How broad the patch should be.'),
+        .describe('Maximum number of test cases to return.'),
 });

package/dist/schemas/outputs.d.ts

@@ -5,6 +5,15 @@ export declare const DefaultOutputSchema: z.ZodObject<{
     error: z.ZodOptional<z.ZodObject<{
         code: z.ZodString;
         message: z.ZodString;
+        retryable: z.ZodOptional<z.ZodBoolean>;
+        kind: z.ZodOptional<z.ZodEnum<{
+            validation: "validation";
+            budget: "budget";
+            upstream: "upstream";
+            timeout: "timeout";
+            cancelled: "cancelled";
+            internal: "internal";
+        }>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export declare const ReviewFindingSchema: z.ZodObject<{
@@ -20,13 +29,58 @@ export declare const ReviewFindingSchema: z.ZodObject<{
     explanation: z.ZodString;
     recommendation: z.ZodString;
 }, z.core.$strict>;
-export declare const ReviewDiffResultSchema: z.ZodObject<{
+export declare const PrImpactResultSchema: z.ZodObject<{
+    severity: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        critical: "critical";
+    }>;
+    categories: z.ZodArray<z.ZodEnum<{
+        breaking_change: "breaking_change";
+        api_change: "api_change";
+        schema_change: "schema_change";
+        config_change: "config_change";
+        dependency_update: "dependency_update";
+        security_fix: "security_fix";
+        deprecation: "deprecation";
+        performance_change: "performance_change";
+        bug_fix: "bug_fix";
+        feature_addition: "feature_addition";
+    }>>;
+    summary: z.ZodString;
+    breakingChanges: z.ZodArray<z.ZodString>;
+    affectedAreas: z.ZodArray<z.ZodString>;
+    rollbackComplexity: z.ZodEnum<{
+        trivial: "trivial";
+        moderate: "moderate";
+        complex: "complex";
+        irreversible: "irreversible";
+    }>;
+}, z.core.$strict>;
+export declare const ReviewSummaryResultSchema: z.ZodObject<{
     summary: z.ZodString;
     overallRisk: z.ZodEnum<{
         low: "low";
         medium: "medium";
         high: "high";
     }>;
+    keyChanges: z.ZodArray<z.ZodString>;
+    recommendation: z.ZodString;
+    stats: z.ZodObject<{
+        filesChanged: z.ZodNumber;
+        linesAdded: z.ZodNumber;
+        linesRemoved: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const CodeQualityResultSchema: z.ZodObject<{
+    summary: z.ZodString;
+    overallRisk: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        critical: "critical";
+    }>;
     findings: z.ZodArray<z.ZodObject<{
         severity: z.ZodEnum<{
             low: "low";
@@ -41,19 +95,88 @@ export declare const ReviewDiffResultSchema: z.ZodObject<{
         recommendation: z.ZodString;
     }, z.core.$strict>>;
     testsNeeded: z.ZodArray<z.ZodString>;
+    contextualInsights: z.ZodArray<z.ZodString>;
 }, z.core.$strict>;
-export declare const RiskScoreResultSchema: z.ZodObject<{
-    score: z.ZodNumber;
-    bucket: z.ZodEnum<{
+export declare const CodeQualityOutputSchema: z.ZodObject<{
+    summary: z.ZodString;
+    overallRisk: z.ZodEnum<{
         low: "low";
         medium: "medium";
         high: "high";
         critical: "critical";
     }>;
-    rationale: z.ZodArray<z.ZodString>;
+    findings: z.ZodArray<z.ZodObject<{
+        severity: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            critical: "critical";
+        }>;
+        file: z.ZodString;
+        line: z.ZodNullable<z.ZodNumber>;
+        title: z.ZodString;
+        explanation: z.ZodString;
+        recommendation: z.ZodString;
+    }, 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;
+    search: z.ZodString;
+    replace: z.ZodString;
+    explanation: z.ZodString;
 }, z.core.$strict>;
-export declare const PatchSuggestionResultSchema: z.ZodObject<{
+export declare const SearchReplaceResultSchema: z.ZodObject<{
     summary: z.ZodString;
-    patch: z.ZodString;
+    blocks: z.ZodArray<z.ZodObject<{
+        file: z.ZodString;
+        search: z.ZodString;
+        replace: z.ZodString;
+        explanation: z.ZodString;
+    }, z.core.$strict>>;
     validationChecklist: z.ZodArray<z.ZodString>;
 }, z.core.$strict>;
+export declare const TestCaseSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        security: "security";
+        performance: "performance";
+        unit: "unit";
+        integration: "integration";
+        e2e: "e2e";
+        regression: "regression";
+    }>;
+    file: z.ZodString;
+    description: z.ZodString;
+    pseudoCode: z.ZodString;
+    priority: z.ZodEnum<{
+        must_have: "must_have";
+        should_have: "should_have";
+        nice_to_have: "nice_to_have";
+    }>;
+}, z.core.$strict>;
+export declare const TestPlanResultSchema: z.ZodObject<{
+    summary: z.ZodString;
+    testCases: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            security: "security";
+            performance: "performance";
+            unit: "unit";
+            integration: "integration";
+            e2e: "e2e";
+            regression: "regression";
+        }>;
+        file: z.ZodString;
+        description: z.ZodString;
+        pseudoCode: z.ZodString;
+        priority: z.ZodEnum<{
+            must_have: "must_have";
+            should_have: "should_have";
+            nice_to_have: "nice_to_have";
+        }>;
+    }, z.core.$strict>>;
+    coverageSummary: z.ZodString;
+}, z.core.$strict>;

package/dist/schemas/outputs.js

@@ -5,26 +5,33 @@ const OUTPUT_LIMITS = {
         lineMin: 1,
         lineMax: 1_000_000,
         title: { min: 3, max: 160 },
-        text: { min: 10, max: 2_000 },
+        text: { min: 1, max: 2_000 },
     },
     reviewDiffResult: {
-        summary: { min: 10, max: 2_000 },
-        findingsMax: 30,
-        testsNeeded: { minItems: 0, maxItems: 12, itemMin: 5, itemMax: 300 },
+        summary: { min: 1, max: 2_000 },
+        findingsMax: 50,
+        testsNeeded: { minItems: 0, maxItems: 20, itemMin: 1, itemMax: 300 },
     },
     riskScoreResult: {
         score: { min: 0, max: 100 },
-        rationale: { minItems: 1, maxItems: 10, itemMin: 8, itemMax: 500 },
+        rationale: { minItems: 1, maxItems: 20, itemMin: 1, itemMax: 500 },
     },
     patchSuggestionResult: {
-        summary: { min: 10, max: 1_000 },
-        patch: { min: 10, max: 60_000 },
-        checklist: { minItems: 1, maxItems: 12, itemMin: 6, itemMax: 300 },
+        summary: { min: 1, max: 1_000 },
+        patch: { min: 1, max: 60_000 },
+        checklist: { minItems: 1, maxItems: 20, itemMin: 1, itemMax: 300 },
     },
 };
 function createBoundedString(min, max, description) {
     return z.string().min(min).max(max).describe(description);
 }
+function createBoundedStringArray(itemMin, itemMax, minItems, maxItems, description) {
+    return z
+        .array(z.string().min(itemMin).max(itemMax))
+        .min(minItems)
+        .max(maxItems)
+        .describe(description);
+}
 export const DefaultOutputSchema = z.strictObject({
     ok: z.boolean().describe('Whether the tool completed successfully.'),
     result: z.unknown().optional().describe('Successful result payload.'),
@@ -32,6 +39,21 @@ export const DefaultOutputSchema = z.strictObject({
         .strictObject({
         code: z.string().describe('Stable error code for callers.'),
         message: z.string().describe('Human readable error details.'),
+        retryable: z
+            .boolean()
+            .optional()
+            .describe('Whether the client should retry this request.'),
+        kind: z
+            .enum([
+            'validation',
+            'budget',
+            'upstream',
+            'timeout',
+            'cancelled',
+            'internal',
+        ])
+            .optional()
+            .describe('Machine-readable error category.'),
     })
         .optional()
         .describe('Error payload when ok is false.'),
@@ -56,44 +78,152 @@ export const ReviewFindingSchema = z.strictObject({
     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.'),
 });
-export const ReviewDiffResultSchema = z.strictObject({
-    summary: createBoundedString(OUTPUT_LIMITS.reviewDiffResult.summary.min, OUTPUT_LIMITS.reviewDiffResult.summary.max, 'Short review summary.'),
+export const PrImpactResultSchema = z.strictObject({
+    severity: z
+        .enum(['low', 'medium', 'high', 'critical'])
+        .describe('Overall impact severity.'),
+    categories: z
+        .array(z.enum([
+        'breaking_change',
+        'api_change',
+        'schema_change',
+        'config_change',
+        'dependency_update',
+        'security_fix',
+        'deprecation',
+        'performance_change',
+        'bug_fix',
+        'feature_addition',
+    ]))
+        .min(0)
+        .max(10)
+        .describe('Impact categories detected in the diff.'),
+    summary: z.string().min(1).max(1000).describe('Concise impact summary.'),
+    breakingChanges: createBoundedStringArray(1, 500, 0, 10, 'Specific breaking changes identified.'),
+    affectedAreas: createBoundedStringArray(1, 200, 0, 20, 'Subsystems or files impacted.'),
+    rollbackComplexity: z
+        .enum(['trivial', 'moderate', 'complex', 'irreversible'])
+        .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('Overall risk for merging this diff.'),
+        .describe('High-level merge risk.'),
+    keyChanges: createBoundedStringArray(1, 300, 1, 15, 'Most important changes, ordered by significance.'),
+    recommendation: z
+        .string()
+        .min(1)
+        .max(500)
+        .describe('Merge readiness recommendation.'),
+    stats: z
+        .strictObject({
+        filesChanged: z
+            .number()
+            .int()
+            .min(0)
+            .describe('Number of files changed.'),
+        linesAdded: z.number().int().min(0).describe('Total lines added.'),
+        linesRemoved: z.number().int().min(0).describe('Total lines removed.'),
+    })
+        .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.describe('Single code review finding.'))
+        .array(ReviewFindingSchema)
         .min(0)
-        .max(OUTPUT_LIMITS.reviewDiffResult.findingsMax)
-        .describe('Ordered list of findings, highest severity first.'),
-    testsNeeded: z
-        .array(createBoundedString(OUTPUT_LIMITS.reviewDiffResult.testsNeeded.itemMin, OUTPUT_LIMITS.reviewDiffResult.testsNeeded.itemMax, 'Test recommendation to reduce risk.'))
-        .min(OUTPUT_LIMITS.reviewDiffResult.testsNeeded.minItems)
-        .max(OUTPUT_LIMITS.reviewDiffResult.testsNeeded.maxItems)
-        .describe('Targeted tests to add before merge.'),
+        .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.'),
 });
-export const RiskScoreResultSchema = z.strictObject({
-    score: z
+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.'),
+    totalFindings: z
         .number()
         .int()
-        .min(OUTPUT_LIMITS.riskScoreResult.score.min)
-        .max(OUTPUT_LIMITS.riskScoreResult.score.max)
-        .describe('Deployment risk score, where 100 is highest risk.'),
-    bucket: z
-        .enum(['low', 'medium', 'high', 'critical'])
-        .describe('Risk bucket derived from score and criticality.'),
-    rationale: z
-        .array(createBoundedString(OUTPUT_LIMITS.riskScoreResult.rationale.itemMin, OUTPUT_LIMITS.riskScoreResult.rationale.itemMax, 'Reason that influenced the final score.'))
-        .min(OUTPUT_LIMITS.riskScoreResult.rationale.minItems)
-        .max(OUTPUT_LIMITS.riskScoreResult.rationale.maxItems)
-        .describe('Evidence-based explanation for the score.'),
+        .min(0)
+        .optional()
+        .describe('Total findings returned by Gemini before maxFindings capping was applied.'),
+});
+export const SearchReplaceBlockSchema = z.strictObject({
+    file: z.string().min(1).max(500).describe('File path to modify.'),
+    search: z
+        .string()
+        .min(1)
+        .max(5000)
+        .describe('Exact verbatim text to find in the file.'),
+    replace: z
+        .string()
+        .min(0)
+        .max(5000)
+        .describe('Replacement text (empty string = deletion).'),
+    explanation: z
+        .string()
+        .min(1)
+        .max(500)
+        .describe('Why this change fixes the finding.'),
+});
+export const SearchReplaceResultSchema = z.strictObject({
+    summary: z.string().min(1).max(1000).describe('What the fix accomplishes.'),
+    blocks: z
+        .array(SearchReplaceBlockSchema)
+        .min(1)
+        .max(10)
+        .describe('Search/replace operations to apply, in order.'),
+    validationChecklist: createBoundedStringArray(1, 300, 1, 12, 'Steps to validate the fix after applying.'),
 });
-export const PatchSuggestionResultSchema = z.strictObject({
-    summary: createBoundedString(OUTPUT_LIMITS.patchSuggestionResult.summary.min, OUTPUT_LIMITS.patchSuggestionResult.summary.max, 'Short patch strategy summary.'),
-    patch: createBoundedString(OUTPUT_LIMITS.patchSuggestionResult.patch.min, OUTPUT_LIMITS.patchSuggestionResult.patch.max, 'Unified diff patch text.'),
-    validationChecklist: z
-        .array(createBoundedString(OUTPUT_LIMITS.patchSuggestionResult.checklist.itemMin, OUTPUT_LIMITS.patchSuggestionResult.checklist.itemMax, 'Validation step after applying patch.'))
-        .min(OUTPUT_LIMITS.patchSuggestionResult.checklist.minItems)
-        .max(OUTPUT_LIMITS.patchSuggestionResult.checklist.maxItems)
-        .describe('Post-change validation actions.'),
+export const TestCaseSchema = z.strictObject({
+    name: z
+        .string()
+        .min(1)
+        .max(200)
+        .describe('Test case name or describe/it string.'),
+    type: z
+        .enum([
+        'unit',
+        'integration',
+        'e2e',
+        'regression',
+        'security',
+        'performance',
+    ])
+        .describe('Category of test.'),
+    file: z.string().min(1).max(500).describe('Suggested test file path.'),
+    description: z.string().min(1).max(1000).describe('What this test verifies.'),
+    pseudoCode: z
+        .string()
+        .min(1)
+        .max(2000)
+        .describe('Pseudocode or starter implementation.'),
+    priority: z
+        .enum(['must_have', 'should_have', 'nice_to_have'])
+        .describe('Priority relative to merge readiness.'),
+});
+export const TestPlanResultSchema = z.strictObject({
+    summary: z.string().min(1).max(1000).describe('Test plan overview.'),
+    testCases: z
+        .array(TestCaseSchema)
+        .min(1)
+        .max(30)
+        .describe('Ordered test cases, must_have first.'),
+    coverageSummary: z
+        .string()
+        .min(1)
+        .max(500)
+        .describe('Summary of coverage gaps this plan addresses.'),
 });

package/dist/server.d.ts

@@ -1,2 +1,6 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-export declare function createServer(): McpServer;
+export interface ServerHandle {
+    server: McpServer;
+    shutdown: () => Promise<void>;
+}
+export declare function createServer(): ServerHandle;