@j0hanz/code-assistant 0.9.0

package/dist/lib/progress.d.ts

@@ -0,0 +1,72 @@
+import type { createErrorToolResponse } from './tools.js';
+export declare const STEP_STARTING = 0;
+export declare const STEP_VALIDATING = 1;
+export declare const STEP_BUILDING_PROMPT = 2;
+export declare const STEP_CALLING_MODEL = 3;
+export declare const STEP_VALIDATING_RESPONSE = 4;
+export declare const STEP_FINALIZING = 5;
+export declare const TASK_PROGRESS_TOTAL: number;
+export declare const INPUT_VALIDATION_FAILED = "Input validation failed";
+export declare const DEFAULT_PROGRESS_CONTEXT = "request";
+type ProgressToken = string | number;
+interface ProgressNotificationParams {
+    progressToken: ProgressToken;
+    progress: number;
+    total?: number;
+    message?: string;
+}
+export interface ProgressPayload {
+    current: number;
+    total?: number;
+    message?: string;
+}
+export interface ProgressExtra {
+    _meta?: {
+        progressToken?: unknown;
+    };
+    sendNotification: (notification: {
+        method: 'notifications/progress';
+        params: ProgressNotificationParams;
+    }) => Promise<void>;
+}
+export declare function getOrCreateProgressReporter(extra: ProgressExtra): (payload: ProgressPayload) => Promise<void>;
+export declare function normalizeProgressContext(context: string | undefined): string;
+export declare function formatProgressStep(toolName: string, context: string, metadata: string): string;
+export declare function formatProgressCompletion(toolName: string, context: string, outcome: string): string;
+export declare function createFailureStatusMessage(outcome: 'failed' | 'cancelled', errorMessage: string): string;
+export declare function extractValidationMessage(validationError: ReturnType<typeof createErrorToolResponse>): string;
+export declare function sendSingleStepProgress(extra: ProgressExtra, toolName: string, context: string, current: 0 | 1, state: 'starting' | 'completed' | 'failed' | 'cancelled'): Promise<void>;
+export declare function reportProgressStepUpdate(reportProgress: (payload: ProgressPayload) => Promise<void>, toolName: string, context: string, current: number, metadata: string): Promise<void>;
+export declare function reportProgressCompletionUpdate(reportProgress: (payload: ProgressPayload) => Promise<void>, toolName: string, context: string, outcome: string): Promise<void>;
+export declare function reportSchemaRetryProgressBestEffort(reportProgress: (payload: ProgressPayload) => Promise<void>, toolName: string, context: string, retryCount: number, maxRetries: number): Promise<void>;
+export interface TaskStatusReporter {
+    updateStatus: (message: string) => Promise<void>;
+    storeResult?: (status: 'completed' | 'failed', result: {
+        isError?: boolean;
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }) => Promise<void>;
+}
+export declare class RunReporter {
+    private readonly toolName;
+    private readonly reportProgress;
+    private readonly statusReporter;
+    private progressContext;
+    private lastStatusMessage;
+    constructor(toolName: string, reportProgress: (payload: ProgressPayload) => Promise<void>, statusReporter: TaskStatusReporter, progressContext: string);
+    updateStatus(message: string): Promise<void>;
+    storeResultSafely(status: 'completed' | 'failed', result: {
+        isError?: boolean;
+        content: {
+            type: string;
+            text: string;
+        }[];
+    }, onLog: (level: string, data: unknown) => Promise<void>): Promise<void>;
+    reportStep(step: number, message: string): Promise<void>;
+    reportCompletion(outcome: string): Promise<void>;
+    reportSchemaRetry(retryCount: number, maxRetries: number): Promise<void>;
+    updateContext(newContext: string): void;
+}
+export {};

package/dist/lib/progress.js

@@ -0,0 +1,204 @@
+import { getErrorMessage } from './errors.js';
+// Named progress step indices for 7-step progress (0–6).
+export const STEP_STARTING = 0;
+export const STEP_VALIDATING = 1;
+export const STEP_BUILDING_PROMPT = 2;
+export const STEP_CALLING_MODEL = 3;
+export const STEP_VALIDATING_RESPONSE = 4;
+export const STEP_FINALIZING = 5;
+export const TASK_PROGRESS_TOTAL = STEP_FINALIZING + 1;
+export const INPUT_VALIDATION_FAILED = 'Input validation failed';
+export const DEFAULT_PROGRESS_CONTEXT = 'request';
+const progressReporterCache = new WeakMap();
+class ProgressReporter {
+    extra;
+    progressToken;
+    lastCurrent = -1;
+    didSendTerminal = false;
+    constructor(extra, progressToken) {
+        this.extra = extra;
+        this.progressToken = progressToken;
+    }
+    async report(payload) {
+        if (this.didSendTerminal) {
+            return;
+        }
+        let { current } = payload;
+        if (current <= this.lastCurrent && current < (payload.total ?? Infinity)) {
+            current = this.lastCurrent + 0.01;
+        }
+        current = Math.max(current, this.lastCurrent);
+        const total = payload.total !== undefined
+            ? Math.max(payload.total, current)
+            : undefined;
+        const progressPayload = { current };
+        if (total !== undefined) {
+            progressPayload.total = total;
+        }
+        if (payload.message !== undefined) {
+            progressPayload.message = payload.message;
+        }
+        const params = {
+            progressToken: this.progressToken,
+            progress: progressPayload.current,
+            ...(progressPayload.total !== undefined
+                ? { total: progressPayload.total }
+                : {}),
+            ...(progressPayload.message !== undefined
+                ? { message: progressPayload.message }
+                : {}),
+        };
+        await this.extra
+            .sendNotification({ method: 'notifications/progress', params })
+            .catch(() => {
+            // Progress notifications are best-effort; never fail tool execution.
+        });
+        this.lastCurrent = current;
+        if (total !== undefined && total === current) {
+            this.didSendTerminal = true;
+        }
+    }
+}
+function createProgressReporter(extra) {
+    const rawToken = extra._meta?.progressToken;
+    if (typeof rawToken !== 'string' && typeof rawToken !== 'number') {
+        return async () => {
+            // Request did not provide a progress token.
+        };
+    }
+    const reporter = new ProgressReporter(extra, rawToken);
+    return (payload) => reporter.report(payload);
+}
+export function getOrCreateProgressReporter(extra) {
+    const cached = progressReporterCache.get(extra);
+    if (cached) {
+        return cached;
+    }
+    const created = createProgressReporter(extra);
+    progressReporterCache.set(extra, created);
+    return created;
+}
+export 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)}...`;
+}
+export function formatProgressStep(toolName, context, metadata) {
+    return formatProgressMessage(toolName, context, metadata);
+}
+export function formatProgressCompletion(toolName, context, outcome) {
+    return formatProgressMessage(toolName, context, outcome);
+}
+function formatProgressMessage(toolName, context, metadata) {
+    return `${toolName}: ${context} [${metadata}]`;
+}
+export function createFailureStatusMessage(outcome, errorMessage) {
+    if (outcome === 'cancelled') {
+        return `cancelled: ${errorMessage}`;
+    }
+    return errorMessage;
+}
+function tryParseErrorMessage(text) {
+    try {
+        const parsed = JSON.parse(text);
+        return parsed.error?.message;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function extractValidationMessage(validationError) {
+    const text = validationError.content.at(0)?.text;
+    if (!text)
+        return INPUT_VALIDATION_FAILED;
+    return tryParseErrorMessage(text) ?? INPUT_VALIDATION_FAILED;
+}
+export async function sendSingleStepProgress(extra, toolName, context, current, state) {
+    const reporter = getOrCreateProgressReporter(extra);
+    await reporter({
+        current,
+        total: 1,
+        message: current === 0
+            ? formatProgressStep(toolName, context, state)
+            : formatProgressCompletion(toolName, context, state),
+    });
+}
+export async function reportProgressStepUpdate(reportProgress, toolName, context, current, metadata) {
+    await reportProgress({
+        current,
+        total: TASK_PROGRESS_TOTAL,
+        message: formatProgressStep(toolName, context, metadata),
+    });
+}
+export async function reportProgressCompletionUpdate(reportProgress, toolName, context, outcome) {
+    await reportProgress({
+        current: TASK_PROGRESS_TOTAL,
+        total: TASK_PROGRESS_TOTAL,
+        message: formatProgressCompletion(toolName, context, outcome),
+    });
+}
+export async function reportSchemaRetryProgressBestEffort(reportProgress, toolName, context, retryCount, maxRetries) {
+    try {
+        await reportProgressStepUpdate(reportProgress, toolName, context, STEP_VALIDATING_RESPONSE + retryCount / (maxRetries + 1), `Schema repair in progress (attempt ${retryCount}/${maxRetries})...`);
+    }
+    catch {
+        // Progress updates are best-effort and must not interrupt retries.
+    }
+}
+export class RunReporter {
+    toolName;
+    reportProgress;
+    statusReporter;
+    progressContext;
+    lastStatusMessage;
+    constructor(toolName, reportProgress, statusReporter, progressContext) {
+        this.toolName = toolName;
+        this.reportProgress = reportProgress;
+        this.statusReporter = statusReporter;
+        this.progressContext = progressContext;
+    }
+    async updateStatus(message) {
+        if (this.lastStatusMessage === message) {
+            return;
+        }
+        try {
+            await this.statusReporter.updateStatus(message);
+            this.lastStatusMessage = message;
+        }
+        catch {
+            // Best-effort
+        }
+    }
+    async storeResultSafely(status, result, onLog) {
+        if (!this.statusReporter.storeResult) {
+            return;
+        }
+        try {
+            await this.statusReporter.storeResult(status, result);
+        }
+        catch (storeErr) {
+            await onLog('error', {
+                event: 'store_result_failed',
+                error: getErrorMessage(storeErr),
+            });
+        }
+    }
+    async reportStep(step, message) {
+        await reportProgressStepUpdate(this.reportProgress, this.toolName, this.progressContext, step, message);
+        await this.updateStatus(message);
+    }
+    async reportCompletion(outcome) {
+        await reportProgressCompletionUpdate(this.reportProgress, this.toolName, this.progressContext, outcome);
+    }
+    async reportSchemaRetry(retryCount, maxRetries) {
+        await reportSchemaRetryProgressBestEffort(this.reportProgress, this.toolName, this.progressContext, retryCount, maxRetries);
+    }
+    updateContext(newContext) {
+        this.progressContext = newContext;
+    }
+}

package/dist/lib/tools.d.ts

@@ -0,0 +1,274 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ZodRawShapeCompat } from '@modelcontextprotocol/sdk/server/zod-compat.js';
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+import { type DiffSlot } from './diff.js';
+import { type DiffStats, type ParsedFile } from './diff.js';
+import { type ProgressExtra, type ProgressPayload, type TaskStatusReporter } from './progress.js';
+export type ErrorKind = 'validation' | 'budget' | 'upstream' | 'timeout' | 'cancelled' | 'internal' | 'busy';
+export interface ErrorMeta {
+    retryable?: boolean;
+    kind?: ErrorKind;
+}
+interface ToolError {
+    code: string;
+    message: string;
+    retryable?: boolean;
+    kind?: ErrorKind;
+}
+interface ToolTextContent {
+    type: 'text';
+    text: string;
+}
+interface ToolStructuredContent {
+    [key: string]: unknown;
+    ok: boolean;
+    result?: unknown;
+    error?: ToolError;
+}
+interface ToolResponse<TStructuredContent extends ToolStructuredContent> {
+    [key: string]: unknown;
+    content: ToolTextContent[];
+    structuredContent: TStructuredContent;
+}
+interface ErrorToolResponse {
+    [key: string]: unknown;
+    content: ToolTextContent[];
+    isError: true;
+}
+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 declare const INSPECTION_FOCUS_AREAS: readonly ["security", "correctness", "performance", "regressions", "tests", "maintainability", "concurrency"];
+export interface ToolParameterContract {
+    name: string;
+    type: string;
+    required: boolean;
+    constraints: string;
+    description: string;
+}
+export interface ToolContract {
+    name: string;
+    purpose: string;
+    /** Set to 'none' for synchronous (non-Gemini) tools. */
+    model: string;
+    /** Set to 0 for synchronous (non-Gemini) tools. */
+    timeoutMs: number;
+    thinkingLevel?: 'minimal' | 'low' | 'medium' | 'high';
+    /** Set to 0 for synchronous (non-Gemini) tools. */
+    maxOutputTokens: number;
+    /**
+     * Sampling temperature for the Gemini call.
+     * Gemini 3 recommends 1.0 for all tasks.
+     */
+    temperature?: number;
+    /** Enables deterministic JSON guidance and schema key ordering. */
+    deterministicJson?: boolean;
+    params: readonly ToolParameterContract[];
+    outputShape: string;
+    gotchas: readonly string[];
+    crossToolFlow: readonly string[];
+    constraints?: readonly string[];
+}
+interface StructuredToolRuntimeOptions {
+    thinkingLevel?: NonNullable<ToolContract['thinkingLevel']>;
+    temperature?: NonNullable<ToolContract['temperature']>;
+    deterministicJson?: NonNullable<ToolContract['deterministicJson']>;
+}
+interface StructuredToolExecutionOptions extends StructuredToolRuntimeOptions {
+    timeoutMs: ToolContract['timeoutMs'];
+    maxOutputTokens: ToolContract['maxOutputTokens'];
+}
+export declare function buildStructuredToolRuntimeOptions(contract: Pick<ToolContract, 'thinkingLevel' | 'temperature' | 'deterministicJson'>): StructuredToolRuntimeOptions;
+export declare function buildStructuredToolExecutionOptions(contract: Pick<ToolContract, 'timeoutMs' | 'maxOutputTokens' | 'thinkingLevel' | 'temperature' | 'deterministicJson'>): StructuredToolExecutionOptions;
+export declare const TOOL_CONTRACTS: readonly [{
+    readonly name: "generate_diff";
+    readonly purpose: "Generate a diff of current changes and cache it server-side. MUST be called before any other tool. Uses git to capture unstaged or staged changes in the current working directory.";
+    readonly model: "none";
+    readonly timeoutMs: 0;
+    readonly maxOutputTokens: 0;
+    readonly params: ToolParameterContract[];
+    readonly outputShape: "{ok, result: {diffRef, stats{files, added, deleted}, generatedAt, mode, message}}";
+    readonly gotchas: readonly ["Must be called first — all other tools return E_NO_DIFF if no diff is cached.", "Noisy files (lock files, dist/, build/, minified assets) are excluded automatically.", "Empty diff (no changes) returns E_NO_CHANGES."];
+    readonly crossToolFlow: readonly ["Caches diff at diff://current — consumed automatically by all review tools."];
+}, {
+    readonly name: "analyze_pr_impact";
+    readonly purpose: "Assess severity, categories, breaking changes, and rollback complexity.";
+    readonly model: "gemini-3-flash-preview";
+    readonly timeoutMs: 90000;
+    readonly thinkingLevel: "minimal";
+    readonly maxOutputTokens: 65536;
+    readonly temperature: 1;
+    readonly deterministicJson: true;
+    readonly params: ToolParameterContract[];
+    readonly outputShape: "{severity, categories[], summary, breakingChanges[], affectedAreas[], rollbackComplexity}";
+    readonly gotchas: readonly ["Requires generate_diff to be called first.", "Flash triage tool optimized for speed."];
+    readonly crossToolFlow: readonly ["severity/categories feed triage and merge-gate decisions."];
+}, {
+    readonly name: "generate_review_summary";
+    readonly purpose: "Produce PR summary, risk rating, and merge recommendation.";
+    readonly model: "gemini-3-flash-preview";
+    readonly timeoutMs: 90000;
+    readonly thinkingLevel: "minimal";
+    readonly maxOutputTokens: 65536;
+    readonly temperature: 1;
+    readonly deterministicJson: true;
+    readonly params: ToolParameterContract[];
+    readonly outputShape: "{summary, overallRisk, keyChanges[], recommendation, stats{filesChanged, linesAdded, linesRemoved}}";
+    readonly gotchas: readonly ["Requires generate_diff to be called first.", "stats are computed locally from the diff."];
+    readonly crossToolFlow: readonly ["Use before deep review to decide whether Pro analysis is needed."];
+}, {
+    readonly name: "generate_test_plan";
+    readonly purpose: "Generate prioritized test cases and coverage guidance.";
+    readonly model: "gemini-3-flash-preview";
+    readonly timeoutMs: 90000;
+    readonly thinkingLevel: "medium";
+    readonly maxOutputTokens: 65536;
+    readonly temperature: 1;
+    readonly deterministicJson: true;
+    readonly params: ToolParameterContract[];
+    readonly outputShape: "{summary, testCases[], coverageSummary}";
+    readonly gotchas: readonly ["Requires generate_diff to be called first.", "maxTestCases caps output after generation."];
+    readonly crossToolFlow: readonly ["Pair with review tools to validate high-risk paths."];
+}, {
+    readonly name: "analyze_time_space_complexity";
+    readonly purpose: "Analyze Big-O complexity and detect degradations in changed code.";
+    readonly model: "gemini-3-flash-preview";
+    readonly timeoutMs: 90000;
+    readonly thinkingLevel: "medium";
+    readonly maxOutputTokens: 65536;
+    readonly temperature: 1;
+    readonly deterministicJson: true;
+    readonly params: ToolParameterContract[];
+    readonly outputShape: "{timeComplexity, spaceComplexity, explanation, potentialBottlenecks[], isDegradation}";
+    readonly gotchas: readonly ["Requires generate_diff to be called first.", "Analyzes only changed code visible in the diff."];
+    readonly crossToolFlow: readonly ["Use for algorithmic/performance-sensitive changes."];
+}, {
+    readonly name: "detect_api_breaking_changes";
+    readonly purpose: "Detect breaking API/interface changes in a diff.";
+    readonly model: "gemini-3-flash-preview";
+    readonly timeoutMs: 90000;
+    readonly thinkingLevel: "minimal";
+    readonly maxOutputTokens: 65536;
+    readonly temperature: 1;
+    readonly deterministicJson: true;
+    readonly params: ToolParameterContract[];
+    readonly outputShape: "{hasBreakingChanges, breakingChanges[]}";
+    readonly gotchas: readonly ["Requires generate_diff to be called first.", "Targets public API contracts over internal refactors."];
+    readonly crossToolFlow: readonly ["Run before merge for API-surface-sensitive changes."];
+}];
+export declare function getToolContracts(): readonly ToolContract[];
+export declare function getToolContract(toolName: string): ToolContract | undefined;
+export declare function requireToolContract(toolName: string): ToolContract;
+export declare function getToolContractNames(): string[];
+export interface PromptParts {
+    systemInstruction: string;
+    prompt: string;
+}
+/**
+ * Immutable snapshot of server-side state captured once at the start of a
+ * tool execution, before `validateInput` runs.  Threading it through both
+ * `validateInput` and `buildPrompt` eliminates the TOCTOU gap that would
+ * otherwise allow a concurrent `generate_diff` call to replace the cached
+ * diff between the budget check and prompt assembly.
+ */
+export interface ToolExecutionContext {
+    readonly diffSlot: DiffSlot | undefined;
+}
+export interface ToolAnnotations {
+    readOnlyHint?: boolean;
+    idempotentHint?: boolean;
+    openWorldHint?: boolean;
+    destructiveHint?: boolean;
+}
+export interface StructuredToolTaskConfig<TInput extends object = Record<string, unknown>, TResult extends object = Record<string, unknown>, TFinal extends TResult = TResult> {
+    /** Tool name registered with the MCP server (e.g. 'analyze_pr_impact'). */
+    name: string;
+    /** Human-readable title shown to clients. */
+    title: string;
+    /** Short description of the tool's purpose. */
+    description: string;
+    /** Zod schema or raw shape for MCP request validation at the transport boundary. */
+    inputSchema: z.ZodType<TInput> | ZodRawShapeCompat;
+    /** Zod schema for validating the complete tool input inside the handler. */
+    fullInputSchema: z.ZodType<TInput>;
+    /** Zod schema for parsing and validating the Gemini structured response. */
+    resultSchema: z.ZodType<TResult>;
+    /** Optional Zod schema used specifically for Gemini response validation. */
+    geminiSchema?: z.ZodType;
+    /** Stable error code returned on failure (e.g. 'E_INSPECT_QUALITY'). */
+    errorCode: string;
+    /** Optional post-processing hook called after resultSchema.parse(). The return value replaces the parsed result. */
+    transformResult?: (input: TInput, result: TResult, ctx: ToolExecutionContext) => TFinal;
+    /** Optional validation hook for input parameters. */
+    validateInput?: (input: TInput, ctx: ToolExecutionContext) => Promise<ReturnType<typeof createErrorToolResponse> | undefined>;
+    /** Optional flag to enforce diff presence and budget check before tool execution. */
+    requiresDiff?: boolean;
+    /** Optional override for schema validation retries. Defaults to GEMINI_SCHEMA_RETRIES env var. */
+    schemaRetries?: number;
+    /** Optional thinking level. */
+    thinkingLevel?: 'minimal' | 'low' | 'medium' | 'high';
+    /** Optional timeout in ms for the Gemini call. Defaults to 90,000 ms. Use DEFAULT_TIMEOUT_PRO_MS for Pro model calls. */
+    timeoutMs?: number;
+    /** Optional max output tokens for Gemini. */
+    maxOutputTokens?: number;
+    /**
+     * Optional sampling temperature for this tool's Gemini call.
+     * Gemini 3 recommends 1.0 for all tasks.
+     */
+    temperature?: number;
+    /** Optional opt-in to Gemini thought output. Defaults to false. */
+    includeThoughts?: boolean;
+    /** Optional deterministic JSON mode for stricter key ordering and repair prompting. */
+    deterministicJson?: boolean;
+    /** Optional batch execution mode. Defaults to runtime setting. */
+    batchMode?: 'off' | 'inline';
+    /** Optional formatter for human-readable text output. */
+    formatOutput?: (result: TFinal) => string;
+    /** Optional context text used in progress messages. */
+    progressContext?: (input: TInput) => string;
+    /** Optional short outcome suffix for the completion progress message (e.g., "3 findings"). */
+    formatOutcome?: (result: TFinal) => string;
+    /** Optional MCP annotation overrides for this tool. */
+    annotations?: ToolAnnotations;
+    /** Builds the system instruction and user prompt from parsed tool input. */
+    buildPrompt: (input: TInput, ctx: ToolExecutionContext) => PromptParts;
+}
+export declare function summarizeSchemaValidationErrorForRetry(errorMessage: string): string;
+export declare function wrapToolHandler<TInput, TResult extends CallToolResult>(options: {
+    toolName: string;
+    progressContext?: (input: TInput) => string;
+}, handler: (input: TInput, extra: ProgressExtra) => Promise<TResult> | TResult): (input: TInput, extra: ProgressExtra) => Promise<TResult>;
+export declare class ToolExecutionRunner<TInput extends object, TResult extends object, TFinal extends TResult> {
+    private readonly config;
+    private readonly signal?;
+    private diffSlotSnapshot;
+    private hasSnapshot;
+    private responseSchema;
+    private readonly onLog;
+    private reporter;
+    constructor(config: StructuredToolTaskConfig<TInput, TResult, TFinal>, dependencies: {
+        onLog: (level: string, data: unknown) => Promise<void>;
+        reportProgress: (payload: ProgressPayload) => Promise<void>;
+        statusReporter: TaskStatusReporter;
+    }, signal?: AbortSignal | undefined);
+    private handleInternalLog;
+    setResponseSchemaOverride(responseSchema: Record<string, unknown>): void;
+    setDiffSlotSnapshot(diffSlotSnapshot: DiffSlot | undefined): void;
+    private executeValidation;
+    private executeModelCallAttempt;
+    private executeModelCall;
+    private createExecutionContext;
+    private applyResultTransform;
+    private formatResultText;
+    private finalizeSuccessfulRun;
+    private handleRunFailure;
+    run(input: unknown): Promise<CallToolResult>;
+}
+export declare function registerStructuredToolTask<TInput extends object, TResult extends object = Record<string, unknown>, TFinal extends TResult = TResult>(server: McpServer, config: StructuredToolTaskConfig<TInput, TResult, TFinal>): void;
+export interface DiffContextSnapshot {
+    diff: string;
+    parsedFiles: readonly ParsedFile[];
+    stats: Readonly<DiffStats>;
+}
+export declare function getDiffContextSnapshot(ctx: ToolExecutionContext): DiffContextSnapshot;
+export {};