windows-exe-decompiler-mcp-server 0.1.0

package/dist/tools/code-function-explain-prepare.js

@@ -0,0 +1,276 @@
+import { z } from 'zod';
+import { createCodeFunctionsReconstructHandler } from './code-functions-reconstruct.js';
+import { persistSemanticExplanationPrepareBundleArtifact, SEMANTIC_EXPLANATION_PREPARE_BUNDLE_ARTIFACT_TYPE, } from '../semantic-name-suggestion-artifacts.js';
+import { buildFunctionExplanationReviewPromptText } from '../prompts/function-explanation-review.js';
+const TOOL_NAME = 'code.function.explain.prepare';
+const PreparedExplanationFunctionSchema = z.object({
+    function: z.string(),
+    address: z.string(),
+    confidence: z.number().min(0).max(1),
+    validated_name: z.string().nullable(),
+    resolution_source: z.string().nullable(),
+    semantic_summary: z.string(),
+    confidence_profile: z.any().optional(),
+    runtime_confidence_profile: z.any().nullable().optional(),
+    naming_confidence_profile: z.any().optional(),
+    behavior_tags: z.array(z.string()).optional(),
+    xref_signals: z.array(z.any()).optional(),
+    call_relationships: z.any().optional(),
+    runtime_context: z.any().nullable().optional(),
+    semantic_evidence: z.any().optional(),
+    source_like_snippet: z.string().nullable().optional(),
+    assembly_excerpt: z.string().nullable().optional(),
+    gaps: z.array(z.string()).optional(),
+});
+const PreparedExplanationBundleSchema = z.object({
+    schema_version: z.literal(1),
+    sample_id: z.string(),
+    analysis_goal: z.string(),
+    generated_at: z.string(),
+    selection: z.object({
+        address: z.string().nullable(),
+        symbol: z.string().nullable(),
+        topk: z.number().int().positive(),
+        max_functions: z.number().int().positive(),
+        include_resolved: z.boolean(),
+        evidence_scope: z.enum(['all', 'latest', 'session']),
+        evidence_session_tag: z.string().nullable(),
+    }),
+    output_contract: z.object({
+        output_root: z.literal('explanations'),
+        required_fields: z.array(z.string()),
+    }),
+    functions: z.array(PreparedExplanationFunctionSchema),
+});
+export const codeFunctionExplainPrepareInputSchema = z
+    .object({
+    sample_id: z.string().describe('Sample ID (format: sha256:<hex>)'),
+    address: z.string().optional().describe('Optional specific function address'),
+    symbol: z.string().optional().describe('Optional specific function symbol'),
+    topk: z
+        .number()
+        .int()
+        .min(1)
+        .max(20)
+        .default(6)
+        .describe('When address/symbol not provided, prepare up to top-K reconstructed functions'),
+    max_functions: z
+        .number()
+        .int()
+        .min(1)
+        .max(20)
+        .default(6)
+        .describe('Maximum number of functions included in the prepared explanation bundle'),
+    include_resolved: z
+        .boolean()
+        .default(true)
+        .describe('Include already resolved functions so the external LLM can explain stable names and unresolved ones together'),
+    analysis_goal: z
+        .string()
+        .min(1)
+        .max(400)
+        .default('Explain the prepared functions in plain language and propose evidence-grounded rewrite guidance.')
+        .describe('Human-readable analysis goal injected into the prompt contract for any external LLM'),
+    persist_artifact: z
+        .boolean()
+        .default(true)
+        .describe('Persist the prepared explanation bundle as a JSON artifact for later review and provenance'),
+    session_tag: z
+        .string()
+        .optional()
+        .describe('Optional semantic explanation session tag used for artifact grouping'),
+    evidence_scope: z
+        .enum(['all', 'latest', 'session'])
+        .default('all')
+        .describe('Runtime evidence scope forwarded to code.functions.reconstruct for explanation preparation'),
+    evidence_session_tag: z
+        .string()
+        .optional()
+        .describe('Optional runtime evidence session selector used when evidence_scope=session or to narrow all/latest results'),
+})
+    .refine((value) => value.evidence_scope !== 'session' || Boolean(value.evidence_session_tag?.trim()), {
+    message: 'evidence_session_tag is required when evidence_scope=session',
+    path: ['evidence_session_tag'],
+});
+export const codeFunctionExplainPrepareOutputSchema = z.object({
+    ok: z.boolean(),
+    data: z
+        .object({
+        sample_id: z.string(),
+        analysis_goal: z.string(),
+        prepared_count: z.number().int().nonnegative(),
+        prompt_name: z.literal('reverse.function_explanation_review'),
+        prompt_arguments: z.object({
+            analysis_goal: z.string(),
+            prepared_bundle_json: z.string(),
+        }),
+        task_prompt: z.string(),
+        prepared_bundle: PreparedExplanationBundleSchema,
+        artifact: z
+            .object({
+            id: z.string(),
+            type: z.literal(SEMANTIC_EXPLANATION_PREPARE_BUNDLE_ARTIFACT_TYPE),
+            path: z.string(),
+            sha256: z.string(),
+            mime: z.string().optional(),
+        })
+            .optional(),
+    })
+        .optional(),
+    warnings: z.array(z.string()).optional(),
+    errors: z.array(z.string()).optional(),
+    artifacts: z.array(z.any()).optional(),
+    metrics: z
+        .object({
+        elapsed_ms: z.number(),
+        tool: z.string(),
+    })
+        .optional(),
+});
+export const codeFunctionExplainPrepareToolDefinition = {
+    name: TOOL_NAME,
+    description: 'Prepare a structured evidence bundle and MCP prompt contract so any tool-calling LLM can explain reconstructed functions and produce a universal output layer.',
+    inputSchema: codeFunctionExplainPrepareInputSchema,
+    outputSchema: codeFunctionExplainPrepareOutputSchema,
+};
+function dedupePreparedFunctions(functions) {
+    const seen = new Set();
+    const deduped = [];
+    for (const item of functions) {
+        const key = `${String(item?.address || 'unknown').toLowerCase()}::${String(item?.function || 'unknown').toLowerCase()}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        deduped.push(item);
+    }
+    return deduped;
+}
+export function createCodeFunctionExplainPrepareHandler(workspaceManager, database, cacheManager, dependencies) {
+    const reconstructHandler = dependencies?.reconstructHandler ||
+        createCodeFunctionsReconstructHandler(workspaceManager, database, cacheManager);
+    return async (args) => {
+        const startTime = Date.now();
+        try {
+            const input = codeFunctionExplainPrepareInputSchema.parse(args);
+            const reconstructResult = await reconstructHandler({
+                sample_id: input.sample_id,
+                address: input.address,
+                symbol: input.symbol,
+                topk: input.topk,
+                include_xrefs: true,
+                max_pseudocode_lines: 80,
+                max_assembly_lines: 60,
+                timeout: 45,
+                evidence_scope: input.evidence_scope,
+                evidence_session_tag: input.evidence_session_tag,
+            });
+            if (!reconstructResult.ok) {
+                return {
+                    ok: false,
+                    errors: reconstructResult.errors || ['code.functions.reconstruct failed'],
+                    warnings: reconstructResult.warnings,
+                    metrics: {
+                        elapsed_ms: Date.now() - startTime,
+                        tool: TOOL_NAME,
+                    },
+                };
+            }
+            const functions = dedupePreparedFunctions((reconstructResult.data?.functions || []))
+                .filter((item) => input.include_resolved || !item?.name_resolution?.validated_name)
+                .slice(0, input.max_functions)
+                .map((item) => ({
+                function: item.function,
+                address: item.address,
+                confidence: item.confidence,
+                validated_name: item?.name_resolution?.validated_name || null,
+                resolution_source: item?.name_resolution?.resolution_source || null,
+                semantic_summary: item.semantic_summary || '',
+                confidence_profile: item.confidence_profile,
+                runtime_confidence_profile: item.runtime_confidence_profile || null,
+                naming_confidence_profile: item.naming_confidence_profile,
+                behavior_tags: Array.isArray(item.behavior_tags) ? item.behavior_tags : [],
+                xref_signals: Array.isArray(item.xref_signals) ? item.xref_signals : [],
+                call_relationships: item.call_relationships || { callers: [], callees: [] },
+                runtime_context: item.runtime_context || null,
+                semantic_evidence: item.semantic_evidence || {},
+                source_like_snippet: item.source_like_snippet || null,
+                assembly_excerpt: item.assembly_excerpt || null,
+                gaps: Array.isArray(item.gaps) ? item.gaps : [],
+            }));
+            const preparedBundle = {
+                schema_version: 1,
+                sample_id: input.sample_id,
+                analysis_goal: input.analysis_goal,
+                generated_at: new Date().toISOString(),
+                selection: {
+                    address: input.address || null,
+                    symbol: input.symbol || null,
+                    topk: input.topk,
+                    max_functions: input.max_functions,
+                    include_resolved: input.include_resolved,
+                    evidence_scope: input.evidence_scope,
+                    evidence_session_tag: input.evidence_session_tag || null,
+                },
+                output_contract: {
+                    output_root: 'explanations',
+                    required_fields: [
+                        'address_or_function',
+                        'summary',
+                        'behavior',
+                        'confidence',
+                        'assumptions',
+                        'evidence_used',
+                        'rewrite_guidance',
+                    ],
+                },
+                functions,
+            };
+            const preparedBundleJson = JSON.stringify(preparedBundle, null, 2);
+            const taskPrompt = buildFunctionExplanationReviewPromptText(preparedBundleJson, input.analysis_goal);
+            const warnings = [...(reconstructResult.warnings || [])];
+            const artifacts = [];
+            let artifact;
+            if (functions.length === 0) {
+                warnings.push('No functions matched the explanation preparation filter. Consider include_resolved=true or a larger topk.');
+            }
+            if (input.persist_artifact) {
+                artifact = await persistSemanticExplanationPrepareBundleArtifact(workspaceManager, database, input.sample_id, preparedBundle, input.session_tag);
+                artifacts.push(artifact);
+            }
+            return {
+                ok: true,
+                data: {
+                    sample_id: input.sample_id,
+                    analysis_goal: input.analysis_goal,
+                    prepared_count: functions.length,
+                    prompt_name: 'reverse.function_explanation_review',
+                    prompt_arguments: {
+                        analysis_goal: input.analysis_goal,
+                        prepared_bundle_json: preparedBundleJson,
+                    },
+                    task_prompt: taskPrompt,
+                    prepared_bundle: preparedBundle,
+                    artifact,
+                },
+                warnings: warnings.length > 0 ? warnings : undefined,
+                artifacts: artifacts.length > 0 ? artifacts : undefined,
+                metrics: {
+                    elapsed_ms: Date.now() - startTime,
+                    tool: TOOL_NAME,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                errors: [error instanceof Error ? error.message : String(error)],
+                metrics: {
+                    elapsed_ms: Date.now() - startTime,
+                    tool: TOOL_NAME,
+                },
+            };
+        }
+    };
+}
+//# sourceMappingURL=code-function-explain-prepare.js.map

package/dist/tools/code-function-explain-review.d.ts

@@ -0,0 +1,397 @@
+import { z } from 'zod';
+import type { ClientCapabilities, CreateMessageRequest, CreateMessageResult, CreateMessageResultWithTools, Implementation } from '@modelcontextprotocol/sdk/types.js';
+import type { ToolArgs, ToolDefinition, WorkerResult } from '../types.js';
+import type { WorkspaceManager } from '../workspace-manager.js';
+import type { DatabaseManager } from '../database.js';
+import type { CacheManager } from '../cache-manager.js';
+import type { MCPServer } from '../server.js';
+export declare const codeFunctionExplainReviewInputSchema: z.ZodEffects<z.ZodObject<{
+    sample_id: z.ZodString;
+    address: z.ZodOptional<z.ZodString>;
+    symbol: z.ZodOptional<z.ZodString>;
+    topk: z.ZodDefault<z.ZodNumber>;
+    max_functions: z.ZodDefault<z.ZodNumber>;
+    include_resolved: z.ZodDefault<z.ZodBoolean>;
+    analysis_goal: z.ZodDefault<z.ZodString>;
+    session_tag: z.ZodOptional<z.ZodString>;
+    evidence_scope: z.ZodDefault<z.ZodEnum<["all", "latest", "session"]>>;
+    evidence_session_tag: z.ZodOptional<z.ZodString>;
+    persist_artifact: z.ZodDefault<z.ZodBoolean>;
+    auto_apply: z.ZodDefault<z.ZodBoolean>;
+    temperature: z.ZodDefault<z.ZodNumber>;
+    max_tokens: z.ZodDefault<z.ZodNumber>;
+    include_context: z.ZodDefault<z.ZodEnum<["none", "thisServer", "allServers"]>>;
+    model_hint: z.ZodOptional<z.ZodString>;
+    cost_priority: z.ZodDefault<z.ZodNumber>;
+    speed_priority: z.ZodDefault<z.ZodNumber>;
+    intelligence_priority: z.ZodDefault<z.ZodNumber>;
+    system_prompt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    sample_id: string;
+    evidence_scope: "all" | "latest" | "session";
+    temperature: number;
+    topk: number;
+    analysis_goal: string;
+    include_resolved: boolean;
+    max_functions: number;
+    persist_artifact: boolean;
+    auto_apply: boolean;
+    max_tokens: number;
+    include_context: "none" | "thisServer" | "allServers";
+    cost_priority: number;
+    speed_priority: number;
+    intelligence_priority: number;
+    symbol?: string | undefined;
+    address?: string | undefined;
+    session_tag?: string | undefined;
+    evidence_session_tag?: string | undefined;
+    model_hint?: string | undefined;
+    system_prompt?: string | undefined;
+}, {
+    sample_id: string;
+    symbol?: string | undefined;
+    address?: string | undefined;
+    session_tag?: string | undefined;
+    evidence_scope?: "all" | "latest" | "session" | undefined;
+    temperature?: number | undefined;
+    topk?: number | undefined;
+    evidence_session_tag?: string | undefined;
+    analysis_goal?: string | undefined;
+    include_resolved?: boolean | undefined;
+    max_functions?: number | undefined;
+    persist_artifact?: boolean | undefined;
+    auto_apply?: boolean | undefined;
+    max_tokens?: number | undefined;
+    include_context?: "none" | "thisServer" | "allServers" | undefined;
+    model_hint?: string | undefined;
+    cost_priority?: number | undefined;
+    speed_priority?: number | undefined;
+    intelligence_priority?: number | undefined;
+    system_prompt?: string | undefined;
+}>, {
+    sample_id: string;
+    evidence_scope: "all" | "latest" | "session";
+    temperature: number;
+    topk: number;
+    analysis_goal: string;
+    include_resolved: boolean;
+    max_functions: number;
+    persist_artifact: boolean;
+    auto_apply: boolean;
+    max_tokens: number;
+    include_context: "none" | "thisServer" | "allServers";
+    cost_priority: number;
+    speed_priority: number;
+    intelligence_priority: number;
+    symbol?: string | undefined;
+    address?: string | undefined;
+    session_tag?: string | undefined;
+    evidence_session_tag?: string | undefined;
+    model_hint?: string | undefined;
+    system_prompt?: string | undefined;
+}, {
+    sample_id: string;
+    symbol?: string | undefined;
+    address?: string | undefined;
+    session_tag?: string | undefined;
+    evidence_scope?: "all" | "latest" | "session" | undefined;
+    temperature?: number | undefined;
+    topk?: number | undefined;
+    evidence_session_tag?: string | undefined;
+    analysis_goal?: string | undefined;
+    include_resolved?: boolean | undefined;
+    max_functions?: number | undefined;
+    persist_artifact?: boolean | undefined;
+    auto_apply?: boolean | undefined;
+    max_tokens?: number | undefined;
+    include_context?: "none" | "thisServer" | "allServers" | undefined;
+    model_hint?: string | undefined;
+    cost_priority?: number | undefined;
+    speed_priority?: number | undefined;
+    intelligence_priority?: number | undefined;
+    system_prompt?: string | undefined;
+}>;
+export declare const codeFunctionExplainReviewOutputSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    data: z.ZodOptional<z.ZodObject<{
+        sample_id: z.ZodString;
+        review_status: z.ZodEnum<["sampled_and_applied", "sampled_only", "prompt_contract_only", "no_targets", "sampling_parse_failed"]>;
+        prompt_name: z.ZodLiteral<"reverse.function_explanation_review">;
+        prompt_arguments: z.ZodObject<{
+            analysis_goal: z.ZodString;
+            prepared_bundle_json: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            prepared_bundle_json: string;
+            analysis_goal: string;
+        }, {
+            prepared_bundle_json: string;
+            analysis_goal: string;
+        }>;
+        task_prompt: z.ZodString;
+        client: z.ZodObject<{
+            name: z.ZodNullable<z.ZodString>;
+            version: z.ZodNullable<z.ZodString>;
+            sampling_available: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            name: string | null;
+            version: string | null;
+            sampling_available: boolean;
+        }, {
+            name: string | null;
+            version: string | null;
+            sampling_available: boolean;
+        }>;
+        prepare: z.ZodObject<{
+            prepared_count: z.ZodNumber;
+            artifact_id: z.ZodNullable<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            artifact_id: string | null;
+            prepared_count: number;
+        }, {
+            artifact_id: string | null;
+            prepared_count: number;
+        }>;
+        sampling: z.ZodObject<{
+            attempted: z.ZodBoolean;
+            model: z.ZodNullable<z.ZodString>;
+            stop_reason: z.ZodNullable<z.ZodString>;
+            response_text: z.ZodNullable<z.ZodString>;
+            parsed_explanation_count: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            model: string | null;
+            attempted: boolean;
+            stop_reason: string | null;
+            response_text: string | null;
+            parsed_explanation_count: number;
+        }, {
+            model: string | null;
+            attempted: boolean;
+            stop_reason: string | null;
+            response_text: string | null;
+            parsed_explanation_count: number;
+        }>;
+        apply: z.ZodObject<{
+            attempted: z.ZodBoolean;
+            accepted_count: z.ZodNumber;
+            rejected_count: z.ZodNumber;
+            artifact_id: z.ZodNullable<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            artifact_id: string | null;
+            attempted: boolean;
+            accepted_count: number;
+            rejected_count: number;
+        }, {
+            artifact_id: string | null;
+            attempted: boolean;
+            accepted_count: number;
+            rejected_count: number;
+        }>;
+        confidence_policy: z.ZodObject<{
+            calibrated: z.ZodBoolean;
+            explanation_scores_are_heuristic: z.ZodBoolean;
+            meaning: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            calibrated: boolean;
+            meaning: string;
+            explanation_scores_are_heuristic: boolean;
+        }, {
+            calibrated: boolean;
+            meaning: string;
+            explanation_scores_are_heuristic: boolean;
+        }>;
+        next_steps: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        sample_id: string;
+        sampling: {
+            model: string | null;
+            attempted: boolean;
+            stop_reason: string | null;
+            response_text: string | null;
+            parsed_explanation_count: number;
+        };
+        client: {
+            name: string | null;
+            version: string | null;
+            sampling_available: boolean;
+        };
+        prompt_name: "reverse.function_explanation_review";
+        prompt_arguments: {
+            prepared_bundle_json: string;
+            analysis_goal: string;
+        };
+        task_prompt: string;
+        next_steps: string[];
+        review_status: "sampled_and_applied" | "sampled_only" | "prompt_contract_only" | "no_targets" | "sampling_parse_failed";
+        prepare: {
+            artifact_id: string | null;
+            prepared_count: number;
+        };
+        apply: {
+            artifact_id: string | null;
+            attempted: boolean;
+            accepted_count: number;
+            rejected_count: number;
+        };
+        confidence_policy: {
+            calibrated: boolean;
+            meaning: string;
+            explanation_scores_are_heuristic: boolean;
+        };
+    }, {
+        sample_id: string;
+        sampling: {
+            model: string | null;
+            attempted: boolean;
+            stop_reason: string | null;
+            response_text: string | null;
+            parsed_explanation_count: number;
+        };
+        client: {
+            name: string | null;
+            version: string | null;
+            sampling_available: boolean;
+        };
+        prompt_name: "reverse.function_explanation_review";
+        prompt_arguments: {
+            prepared_bundle_json: string;
+            analysis_goal: string;
+        };
+        task_prompt: string;
+        next_steps: string[];
+        review_status: "sampled_and_applied" | "sampled_only" | "prompt_contract_only" | "no_targets" | "sampling_parse_failed";
+        prepare: {
+            artifact_id: string | null;
+            prepared_count: number;
+        };
+        apply: {
+            artifact_id: string | null;
+            attempted: boolean;
+            accepted_count: number;
+            rejected_count: number;
+        };
+        confidence_policy: {
+            calibrated: boolean;
+            meaning: string;
+            explanation_scores_are_heuristic: boolean;
+        };
+    }>>;
+    warnings: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    errors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    artifacts: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    metrics: z.ZodOptional<z.ZodObject<{
+        elapsed_ms: z.ZodNumber;
+        tool: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        elapsed_ms: number;
+        tool: string;
+    }, {
+        elapsed_ms: number;
+        tool: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    ok: boolean;
+    metrics?: {
+        elapsed_ms: number;
+        tool: string;
+    } | undefined;
+    data?: {
+        sample_id: string;
+        sampling: {
+            model: string | null;
+            attempted: boolean;
+            stop_reason: string | null;
+            response_text: string | null;
+            parsed_explanation_count: number;
+        };
+        client: {
+            name: string | null;
+            version: string | null;
+            sampling_available: boolean;
+        };
+        prompt_name: "reverse.function_explanation_review";
+        prompt_arguments: {
+            prepared_bundle_json: string;
+            analysis_goal: string;
+        };
+        task_prompt: string;
+        next_steps: string[];
+        review_status: "sampled_and_applied" | "sampled_only" | "prompt_contract_only" | "no_targets" | "sampling_parse_failed";
+        prepare: {
+            artifact_id: string | null;
+            prepared_count: number;
+        };
+        apply: {
+            artifact_id: string | null;
+            attempted: boolean;
+            accepted_count: number;
+            rejected_count: number;
+        };
+        confidence_policy: {
+            calibrated: boolean;
+            meaning: string;
+            explanation_scores_are_heuristic: boolean;
+        };
+    } | undefined;
+    warnings?: string[] | undefined;
+    errors?: string[] | undefined;
+    artifacts?: any[] | undefined;
+}, {
+    ok: boolean;
+    metrics?: {
+        elapsed_ms: number;
+        tool: string;
+    } | undefined;
+    data?: {
+        sample_id: string;
+        sampling: {
+            model: string | null;
+            attempted: boolean;
+            stop_reason: string | null;
+            response_text: string | null;
+            parsed_explanation_count: number;
+        };
+        client: {
+            name: string | null;
+            version: string | null;
+            sampling_available: boolean;
+        };
+        prompt_name: "reverse.function_explanation_review";
+        prompt_arguments: {
+            prepared_bundle_json: string;
+            analysis_goal: string;
+        };
+        task_prompt: string;
+        next_steps: string[];
+        review_status: "sampled_and_applied" | "sampled_only" | "prompt_contract_only" | "no_targets" | "sampling_parse_failed";
+        prepare: {
+            artifact_id: string | null;
+            prepared_count: number;
+        };
+        apply: {
+            artifact_id: string | null;
+            attempted: boolean;
+            accepted_count: number;
+            rejected_count: number;
+        };
+        confidence_policy: {
+            calibrated: boolean;
+            meaning: string;
+            explanation_scores_are_heuristic: boolean;
+        };
+    } | undefined;
+    warnings?: string[] | undefined;
+    errors?: string[] | undefined;
+    artifacts?: any[] | undefined;
+}>;
+export declare const codeFunctionExplainReviewToolDefinition: ToolDefinition;
+type SamplingResult = CreateMessageResult | CreateMessageResultWithTools;
+interface CodeFunctionExplainReviewDependencies {
+    prepareHandler?: (args: ToolArgs) => Promise<WorkerResult>;
+    applyHandler?: (args: ToolArgs) => Promise<WorkerResult>;
+    samplingRequester?: (params: CreateMessageRequest['params']) => Promise<SamplingResult>;
+    clientCapabilitiesProvider?: () => ClientCapabilities | undefined;
+    clientVersionProvider?: () => Implementation | undefined;
+}
+export declare function createCodeFunctionExplainReviewHandler(workspaceManager: WorkspaceManager, database: DatabaseManager, cacheManager: CacheManager, mcpServer?: MCPServer, dependencies?: CodeFunctionExplainReviewDependencies): (args: ToolArgs) => Promise<WorkerResult>;
+export {};
+//# sourceMappingURL=code-function-explain-review.d.ts.map