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

package/dist/lib/tool-factory.js

@@ -1,9 +1,17 @@
 import { z } from 'zod';
 import { DefaultOutputSchema } from '../schemas/outputs.js';
-import { getErrorMessage } from './errors.js';
+import { getErrorMessage, RETRYABLE_UPSTREAM_ERROR_PATTERN } from './errors.js';
 import { stripJsonSchemaConstraints } from './gemini-schema.js';
-import { generateStructuredJson } from './gemini.js';
+import { generateStructuredJson, getCurrentRequestId } from './gemini.js';
 import { createErrorToolResponse, createToolResponse, } from './tool-response.js';
+const DEFAULT_TASK_TTL_MS = 30 * 60 * 1_000;
+const TASK_PROGRESS_TOTAL = 4;
+const INPUT_VALIDATION_FAILED = 'Input validation failed';
+const DEFAULT_PROGRESS_CONTEXT = 'request';
+const CANCELLED_ERROR_PATTERN = /cancelled|canceled/i;
+const TIMEOUT_ERROR_PATTERN = /timed out|timeout/i;
+const BUDGET_ERROR_PATTERN = /exceeds limit|max allowed size|input too large/i;
+const BUSY_ERROR_PATTERN = /too many concurrent/i;
 function createGeminiResponseSchema(config) {
     const sourceSchema = config.geminiSchema ?? config.resultSchema;
     return stripJsonSchemaConstraints(z.toJSONSchema(sourceSchema));
@@ -11,6 +19,173 @@ function createGeminiResponseSchema(config) {
 function parseToolInput(input, fullInputSchema) {
     return fullInputSchema.parse(input);
 }
+function createGenerationRequest(config, promptParts, responseSchema, onLog, signal) {
+    const request = {
+        systemInstruction: promptParts.systemInstruction,
+        prompt: promptParts.prompt,
+        responseSchema,
+        onLog,
+    };
+    if (config.model !== undefined) {
+        request.model = config.model;
+    }
+    if (config.thinkingBudget !== undefined) {
+        request.thinkingBudget = config.thinkingBudget;
+    }
+    if (config.timeoutMs !== undefined) {
+        request.timeoutMs = config.timeoutMs;
+    }
+    if (signal !== undefined) {
+        request.signal = signal;
+    }
+    return request;
+}
+function classifyErrorMeta(error, message) {
+    if (error instanceof z.ZodError || /validation/i.test(message)) {
+        return {
+            kind: 'validation',
+            retryable: false,
+        };
+    }
+    if (CANCELLED_ERROR_PATTERN.test(message)) {
+        return {
+            kind: 'cancelled',
+            retryable: false,
+        };
+    }
+    if (TIMEOUT_ERROR_PATTERN.test(message)) {
+        return {
+            kind: 'timeout',
+            retryable: true,
+        };
+    }
+    if (BUDGET_ERROR_PATTERN.test(message)) {
+        return {
+            kind: 'budget',
+            retryable: false,
+        };
+    }
+    if (RETRYABLE_UPSTREAM_ERROR_PATTERN.test(message)) {
+        return {
+            kind: 'upstream',
+            retryable: true,
+        };
+    }
+    if (BUSY_ERROR_PATTERN.test(message)) {
+        return {
+            kind: 'upstream',
+            retryable: true,
+        };
+    }
+    return {
+        kind: 'internal',
+        retryable: false,
+    };
+}
+async function sendTaskProgress(extra, payload) {
+    const progressToken = extra._meta?.progressToken;
+    if (typeof progressToken !== 'string' && typeof progressToken !== 'number') {
+        return;
+    }
+    try {
+        const params = {
+            progressToken,
+            progress: payload.current,
+        };
+        if (payload.total !== undefined) {
+            params.total = payload.total;
+        }
+        if (payload.message !== undefined) {
+            params.message = payload.message;
+        }
+        await extra.sendNotification({
+            method: 'notifications/progress',
+            params,
+        });
+    }
+    catch {
+        // Progress is best-effort; never fail the tool call.
+    }
+}
+function createProgressReporter(extra) {
+    let lastCurrent = 0;
+    let didSendTerminal = false;
+    return async (payload) => {
+        if (didSendTerminal) {
+            return;
+        }
+        const current = Math.max(payload.current, lastCurrent);
+        const total = payload.total !== undefined
+            ? Math.max(payload.total, current)
+            : undefined;
+        await sendTaskProgress(extra, {
+            current,
+            ...(total !== undefined ? { total } : {}),
+            ...(payload.message !== undefined ? { message: payload.message } : {}),
+        });
+        lastCurrent = current;
+        if (total !== undefined && total === current) {
+            didSendTerminal = true;
+        }
+    };
+}
+function normalizeProgressContext(context) {
+    const compact = context?.replace(/\s+/g, ' ').trim();
+    if (!compact) {
+        return DEFAULT_PROGRESS_CONTEXT;
+    }
+    if (compact.length <= 80) {
+        return compact;
+    }
+    return `${compact.slice(0, 77)}...`;
+}
+function formatProgressStep(toolName, context, metadata) {
+    const prefix = metadata === 'start' ? '▸' : '◆';
+    return `${prefix} ${toolName}: ${context} [${metadata}]`;
+}
+function formatProgressCompletion(toolName, context, outcome) {
+    const prefix = outcome === 'completed' ? '◈' : '‣';
+    return `${prefix} ${toolName}: ${context} • ${outcome}`;
+}
+function toLoggingLevel(level) {
+    switch (level) {
+        case 'debug':
+        case 'info':
+        case 'notice':
+        case 'warning':
+        case 'error':
+        case 'critical':
+        case 'alert':
+        case 'emergency':
+            return level;
+        default:
+            return 'error';
+    }
+}
+function asObjectRecord(value) {
+    if (typeof value === 'object' && value !== null) {
+        return value;
+    }
+    return { payload: value };
+}
+function createGeminiLogger(server, taskId) {
+    return async (level, data) => {
+        try {
+            await server.sendLoggingMessage({
+                level: toLoggingLevel(level),
+                logger: 'gemini',
+                data: {
+                    requestId: getCurrentRequestId(),
+                    taskId,
+                    ...asObjectRecord(data),
+                },
+            });
+        }
+        catch {
+            // Logging is best-effort; never fail the tool call.
+        }
+    };
+}
 export function registerStructuredToolTask(server, config) {
     const responseSchema = createGeminiResponseSchema({
         geminiSchema: config.geminiSchema,
@@ -25,83 +200,105 @@ export function registerStructuredToolTask(server, config) {
             readOnlyHint: true,
             openWorldHint: true,
         },
-        execution: {
-            taskSupport: 'optional',
-        },
     }, {
         createTask: async (input, extra) => {
             const task = await extra.taskStore.createTask({
-                ttl: extra.taskRequestedTtl ?? null,
+                ttl: extra.taskRequestedTtl ?? DEFAULT_TASK_TTL_MS,
             });
-            const progressToken = extra._meta?.progressToken;
-            const sendProgress = async (progress, total) => {
-                if (progressToken == null)
-                    return;
-                try {
-                    await extra.sendNotification({
-                        method: 'notifications/progress',
-                        params: { progressToken, progress, total },
-                    });
-                }
-                catch {
-                    // Progress is best-effort; never fail the tool call.
-                }
-            };
-            const updateStatusMessage = async (message) => {
-                try {
-                    await extra.taskStore.updateTaskStatus(task.taskId, 'working', message);
-                }
-                catch {
-                    // statusMessage is best-effort; task may already be terminal.
-                }
-            };
-            try {
-                const onLog = async (level, data) => {
+            const runTask = async () => {
+                const reportProgress = createProgressReporter(extra);
+                let progressContext = DEFAULT_PROGRESS_CONTEXT;
+                const updateStatusMessage = async (message) => {
                     try {
-                        await server.sendLoggingMessage({
-                            level: level,
-                            logger: 'gemini',
-                            data,
-                        });
+                        await extra.taskStore.updateTaskStatus(task.taskId, 'working', message);
                     }
                     catch {
-                        // Logging is best-effort; never fail the tool call.
+                        // statusMessage is best-effort; task may already be terminal.
                     }
                 };
-                const inputRecord = parseToolInput(input, config.fullInputSchema);
-                if (config.validateInput) {
-                    const validationError = await config.validateInput(inputRecord);
-                    if (validationError) {
-                        const validationMessage = validationError.structuredContent.error?.message ??
-                            'Input validation failed';
-                        await updateStatusMessage(validationMessage);
-                        await extra.taskStore.storeTaskResult(task.taskId, 'failed', validationError);
-                        return { task };
+                const storeResultSafely = async (status, result) => {
+                    try {
+                        await extra.taskStore.storeTaskResult(task.taskId, status, result);
+                    }
+                    catch {
+                        // storing the result failed, possibly because the task is already marked as failed due to an uncaught error. There's not much we can do at this point, so we swallow the error to avoid unhandled rejections.
+                    }
+                };
+                try {
+                    await reportProgress({
+                        current: 0,
+                        total: TASK_PROGRESS_TOTAL,
+                        message: formatProgressStep(config.name, progressContext, 'start'),
+                    });
+                    const onLog = createGeminiLogger(server, task.taskId);
+                    const inputRecord = parseToolInput(input, config.fullInputSchema);
+                    progressContext = normalizeProgressContext(config.progressContext?.(inputRecord));
+                    if (config.validateInput) {
+                        const validationError = await config.validateInput(inputRecord);
+                        if (validationError) {
+                            const validationMessage = validationError.structuredContent.error?.message ??
+                                INPUT_VALIDATION_FAILED;
+                            await updateStatusMessage(validationMessage);
+                            await reportProgress({
+                                current: TASK_PROGRESS_TOTAL,
+                                total: TASK_PROGRESS_TOTAL,
+                                message: formatProgressCompletion(config.name, progressContext, 'failed'),
+                            });
+                            await storeResultSafely('completed', validationError);
+                            return;
+                        }
                     }
+                    await reportProgress({
+                        current: 1,
+                        total: TASK_PROGRESS_TOTAL,
+                        message: formatProgressStep(config.name, progressContext, 'input validated'),
+                    });
+                    const { systemInstruction, prompt } = config.buildPrompt(inputRecord);
+                    await reportProgress({
+                        current: 2,
+                        total: TASK_PROGRESS_TOTAL,
+                        message: formatProgressStep(config.name, progressContext, 'prompt prepared'),
+                    });
+                    const raw = await generateStructuredJson(createGenerationRequest(config, { systemInstruction, prompt }, responseSchema, onLog, extra.signal));
+                    await reportProgress({
+                        current: 3,
+                        total: TASK_PROGRESS_TOTAL,
+                        message: formatProgressStep(config.name, progressContext, 'model response received'),
+                    });
+                    const parsed = config.resultSchema.parse(raw);
+                    const finalResult = (config.transformResult
+                        ? config.transformResult(inputRecord, parsed)
+                        : parsed);
+                    const textContent = config.formatOutput
+                        ? config.formatOutput(finalResult)
+                        : undefined;
+                    await reportProgress({
+                        current: TASK_PROGRESS_TOTAL,
+                        total: TASK_PROGRESS_TOTAL,
+                        message: formatProgressCompletion(config.name, progressContext, 'completed'),
+                    });
+                    await storeResultSafely('completed', createToolResponse({
+                        ok: true,
+                        result: finalResult,
+                    }, textContent));
                 }
-                await sendProgress(1, 4);
-                const { systemInstruction, prompt } = config.buildPrompt(inputRecord);
-                await sendProgress(2, 4);
-                const raw = await generateStructuredJson({
-                    systemInstruction,
-                    prompt,
-                    responseSchema,
-                    signal: extra.signal,
-                    onLog,
+                catch (error) {
+                    const errorMessage = getErrorMessage(error);
+                    const errorMeta = classifyErrorMeta(error, errorMessage);
+                    await reportProgress({
+                        current: TASK_PROGRESS_TOTAL,
+                        total: TASK_PROGRESS_TOTAL,
+                        message: formatProgressCompletion(config.name, progressContext, 'failed'),
+                    });
+                    await updateStatusMessage(errorMessage);
+                    await storeResultSafely('failed', createErrorToolResponse(config.errorCode, errorMessage, undefined, errorMeta));
+                }
+            };
+            queueMicrotask(() => {
+                void runTask().catch((error) => {
+                    console.error(`[task-runner:${config.name}] ${getErrorMessage(error)}`);
                 });
-                await sendProgress(3, 4);
-                const parsed = config.resultSchema.parse(raw);
-                await extra.taskStore.storeTaskResult(task.taskId, 'completed', createToolResponse({
-                    ok: true,
-                    result: parsed,
-                }));
-                await sendProgress(4, 4);
-            }
-            catch (error) {
-                const errorMessage = getErrorMessage(error);
-                await updateStatusMessage(errorMessage);
-                await extra.taskStore.storeTaskResult(task.taskId, 'failed', createErrorToolResponse(config.errorCode, errorMessage));
-            }
+            });
             return { task };
         },
         getTask: async (_input, extra) => {

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

@@ -1,6 +1,13 @@
+export type ErrorKind = 'validation' | 'budget' | 'upstream' | 'timeout' | 'cancelled' | 'internal';
+export interface ErrorMeta {
+    retryable?: boolean;
+    kind?: ErrorKind;
+}
 interface ToolError {
     code: string;
     message: string;
+    retryable?: boolean;
+    kind?: ErrorKind;
 }
 interface ToolTextContent {
     type: 'text';
@@ -20,6 +27,6 @@ interface ToolResponse<TStructuredContent extends ToolStructuredContent> {
 interface ErrorToolResponse extends ToolResponse<ToolStructuredContent> {
     isError: true;
 }
-export declare function createToolResponse<TStructuredContent extends ToolStructuredContent>(structured: TStructuredContent): ToolResponse<TStructuredContent>;
-export declare function createErrorToolResponse(code: string, message: string, result?: unknown): ErrorToolResponse;
+export declare function createToolResponse<TStructuredContent extends ToolStructuredContent>(structured: TStructuredContent, textContent?: string): ToolResponse<TStructuredContent>;
+export declare function createErrorToolResponse(code: string, message: string, result?: unknown, meta?: ErrorMeta): ErrorToolResponse;
 export {};

package/dist/lib/tool-response.js

@@ -1,23 +1,38 @@
-function toTextContent(structured) {
-    return [{ type: 'text', text: JSON.stringify(structured) }];
+function toTextContent(structured, textContent) {
+    const text = textContent ?? JSON.stringify(structured);
+    return [{ type: 'text', text }];
 }
-function createErrorStructuredContent(code, message, result) {
-    if (result === undefined) {
-        return { ok: false, error: { code, message } };
-    }
-    return { ok: false, error: { code, message }, result };
-}
-export function createToolResponse(structured) {
+function buildToolResponse(structured, textContent) {
     return {
-        content: toTextContent(structured),
+        content: toTextContent(structured, textContent),
         structuredContent: structured,
     };
 }
-export function createErrorToolResponse(code, message, result) {
-    const structured = createErrorStructuredContent(code, message, result);
+function createErrorStructuredContent(code, message, result, meta) {
+    const error = {
+        code,
+        message,
+    };
+    if (meta?.retryable !== undefined) {
+        error.retryable = meta.retryable;
+    }
+    if (meta?.kind !== undefined) {
+        error.kind = meta.kind;
+    }
+    if (result === undefined) {
+        return { ok: false, error };
+    }
+    return { ok: false, error, result };
+}
+export function createToolResponse(structured, textContent) {
+    return buildToolResponse(structured, textContent);
+}
+export function createErrorToolResponse(code, message, result, meta) {
+    const structured = createErrorStructuredContent(code, message, result, meta);
+    const base = buildToolResponse(structured);
     return {
-        content: toTextContent(structured),
-        structuredContent: structured,
+        content: base.content,
+        structuredContent: base.structuredContent,
         isError: true,
     };
 }

package/dist/lib/types.d.ts

@@ -1,15 +1,20 @@
 export type JsonObject = Record<string, unknown>;
-export interface GeminiStructuredRequestOptions {
-    model?: string;
+export type GeminiLogHandler = (level: string, data: unknown) => Promise<void>;
+interface GeminiRequestExecutionOptions {
     maxRetries?: number;
     timeoutMs?: number;
     temperature?: number;
     maxOutputTokens?: number;
+    thinkingBudget?: number;
     signal?: AbortSignal;
-    onLog?: (level: string, data: unknown) => Promise<void>;
+    onLog?: GeminiLogHandler;
+}
+export interface GeminiStructuredRequestOptions extends GeminiRequestExecutionOptions {
+    model?: string;
 }
 export interface GeminiStructuredRequest extends GeminiStructuredRequestOptions {
     systemInstruction?: string;
     prompt: string;
     responseSchema: JsonObject;
 }
+export {};

package/dist/prompts/index.js

@@ -1,10 +1,18 @@
 import { completable } from '@modelcontextprotocol/sdk/server/completable.js';
 import { z } from 'zod';
 const HELP_PROMPT_NAME = 'get-help';
+const HELP_PROMPT_TITLE = 'Get Help';
 const HELP_PROMPT_DESCRIPTION = 'Return the server usage instructions.';
 const REVIEW_GUIDE_PROMPT_NAME = 'review-guide';
+const REVIEW_GUIDE_PROMPT_TITLE = 'Review Guide';
 const REVIEW_GUIDE_PROMPT_DESCRIPTION = 'Guided workflow instructions for a specific code review tool and focus area.';
-const TOOLS = ['review_diff', 'risk_score', 'suggest_patch'];
+const TOOLS = [
+    'analyze_pr_impact',
+    'generate_review_summary',
+    'inspect_code_quality',
+    'suggest_search_replace',
+    'generate_test_plan',
+];
 const FOCUS_AREAS = [
     'security',
     'correctness',
@@ -13,14 +21,13 @@ const FOCUS_AREAS = [
     'tests',
 ];
 const TOOL_GUIDES = {
-    review_diff: 'Call `review_diff` with `diff` (unified diff text) and `repository` (org/repo). ' +
-        'Optional: `focusAreas` array and `maxFindings` cap. ' +
-        'Returns structured findings, overallRisk, and test recommendations.',
-    risk_score: 'Call `risk_score` with `diff`. Optional: `deploymentCriticality` (low, medium, high). ' +
-        'Returns a 0–100 score, bucket, and rationale for release gating.',
-    suggest_patch: 'First call `review_diff` to get findings. Then call `suggest_patch` with `diff`, ' +
-        '`findingTitle`, and `findingDetails` from one finding. ' +
-        'Optional: `patchStyle` (minimal, balanced, defensive). One finding per call.',
+    analyze_pr_impact: 'Call `analyze_pr_impact` with `diff` and `repository`. ' +
+        'Get severity rating and categorization.',
+    generate_review_summary: 'Call `generate_review_summary` for a concise digest and merge recommendation.',
+    inspect_code_quality: 'Call `inspect_code_quality` for deep review with optional file context. ' +
+        'Uses thinking model for complex reasoning.',
+    suggest_search_replace: 'Call `suggest_search_replace` to generate verbatim search/replace fixes.',
+    generate_test_plan: 'Call `generate_test_plan` to create a verification strategy.',
 };
 const FOCUS_AREA_GUIDES = {
     security: 'Audit for injection vulnerabilities, insecure data handling, broken authentication, ' +
@@ -34,15 +41,28 @@ const FOCUS_AREA_GUIDES = {
     tests: 'Assess test coverage gaps, missing edge case tests, flaky test patterns, ' +
         'and untested error paths.',
 };
+function completeByPrefix(values, prefix) {
+    const matches = [];
+    for (const value of values) {
+        if (value.startsWith(prefix)) {
+            matches.push(value);
+        }
+    }
+    return matches;
+}
+function getGuide(guides, value, fallback) {
+    const guide = guides[value];
+    return guide ?? fallback(value);
+}
 function getToolGuide(tool) {
-    return TOOL_GUIDES[tool] ?? `Use \`${tool}\` to analyze your code changes.`;
+    return getGuide(TOOL_GUIDES, tool, (toolName) => `Use \`${toolName}\` to analyze your code changes.`);
 }
 function getFocusAreaGuide(focusArea) {
-    return FOCUS_AREA_GUIDES[focusArea] ?? `Focus on ${focusArea} concerns.`;
+    return getGuide(FOCUS_AREA_GUIDES, focusArea, (area) => `Focus on ${area} concerns.`);
 }
 export function registerAllPrompts(server, instructions) {
     server.registerPrompt(HELP_PROMPT_NAME, {
-        title: 'Get Help',
+        title: HELP_PROMPT_TITLE,
         description: 'Return the server usage instructions.',
     }, () => ({
         description: HELP_PROMPT_DESCRIPTION,
@@ -57,15 +77,15 @@ export function registerAllPrompts(server, instructions) {
         ],
     }));
     server.registerPrompt(REVIEW_GUIDE_PROMPT_NAME, {
-        title: 'Review Guide',
+        title: REVIEW_GUIDE_PROMPT_TITLE,
         description: REVIEW_GUIDE_PROMPT_DESCRIPTION,
         argsSchema: {
             tool: completable(z
                 .string()
-                .describe('Which review tool to use: review_diff, risk_score, or suggest_patch'), (value) => TOOLS.filter((t) => t.startsWith(value))),
+                .describe('Which review tool to use: analyze_pr_impact, generate_review_summary, etc.'), (value) => completeByPrefix(TOOLS, value)),
             focusArea: completable(z
                 .string()
-                .describe('Focus area: security, correctness, performance, regressions, or tests'), (value) => FOCUS_AREAS.filter((f) => f.startsWith(value))),
+                .describe('Focus area: security, correctness, performance, regressions, or tests'), (value) => completeByPrefix(FOCUS_AREAS, value)),
         },
     }, ({ tool, focusArea }) => ({
         description: `Code review guide: ${tool} / ${focusArea}`,

package/dist/resources/index.js

@@ -1,16 +1,17 @@
 const RESOURCE_ID = 'server-instructions';
 const RESOURCE_URI = 'internal://instructions';
 const RESOURCE_MIME_TYPE = 'text/markdown';
+const RESOURCE_METADATA = {
+    title: 'Server Instructions',
+    description: 'Guidance for using the MCP tools effectively.',
+    mimeType: RESOURCE_MIME_TYPE,
+    annotations: {
+        audience: ['assistant'],
+        priority: 0.8,
+    },
+};
 export function registerAllResources(server, instructions) {
-    server.registerResource(RESOURCE_ID, RESOURCE_URI, {
-        title: 'Server Instructions',
-        description: 'Guidance for using the MCP tools effectively.',
-        mimeType: RESOURCE_MIME_TYPE,
-        annotations: {
-            audience: ['assistant'],
-            priority: 0.8,
-        },
-    }, (uri) => ({
+    server.registerResource(RESOURCE_ID, RESOURCE_URI, RESOURCE_METADATA, (uri) => ({
         contents: [
             {
                 uri: uri.href,

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>;