@lunatest/mcp 0.1.0 → 0.1.1

package/dist/generation/mutator.d.ts

@@ -1,5 +1,8 @@
+import type { CoverageCatalog } from "@lunatest/contracts";
 import type { ScenarioDescriptor } from "../tools/scenario.js";
 export declare function mutateValues(lua: string, variantIndex: number): string;
 export declare function mutateStages(lua: string, variantIndex: number): string;
 export declare function mutateMocks(lua: string, variantIndex: number): string;
-export declare function mutateScenarioVariants(source: ScenarioDescriptor, count: number): ScenarioDescriptor[];
+export declare function mutateScenarioVariants(source: ScenarioDescriptor, count: number, options?: {
+    missingTargets?: CoverageCatalog;
+}): ScenarioDescriptor[];

package/dist/generation/mutator.js

@@ -31,16 +31,40 @@ export function mutateMocks(lua, variantIndex) {
     }
     return `${lua}\n-- mock-state mutation ${variantIndex}`;
 }
-export function mutateScenarioVariants(source, count) {
+export function mutateScenarioVariants(source, count, options = {}) {
     const variants = [];
+    const missingFeatures = options.missingTargets?.features ?? [];
+    const missingStates = options.missingTargets?.states ?? [];
+    const missingComponents = options.missingTargets?.components ?? [];
     for (let index = 1; index <= count; index += 1) {
         const variantLua = source.lua
             ? mutateMocks(mutateStages(mutateValues(source.lua, index), index), index)
             : undefined;
+        const feature = missingFeatures[(index - 1) % Math.max(missingFeatures.length, 1)];
+        const state = missingStates[(index - 1) % Math.max(missingStates.length, 1)];
+        const component = missingComponents[(index - 1) % Math.max(missingComponents.length, 1)];
         const variant = {
             ...source,
             id: `${source.id}-mut-${index}`,
             name: `${source.name} mutation ${index}`,
+            tags: Array.from(new Set([
+                ...(source.tags ?? []),
+                "mutated",
+            ])),
+            coverage: {
+                features: Array.from(new Set([
+                    ...(source.coverage?.features ?? []),
+                    ...(feature ? [feature] : []),
+                ])),
+                states: Array.from(new Set([
+                    ...(source.coverage?.states ?? []),
+                    ...(state ? [state] : []),
+                ])),
+                components: Array.from(new Set([
+                    ...(source.coverage?.components ?? []),
+                    ...(component ? [component] : []),
+                ])),
+            },
         };
         if (variantLua !== undefined) {
             variant.lua = variantLua;

package/dist/resources/index.d.ts

@@ -7,5 +7,11 @@ export declare function createResourceCatalog(options: {
     scenarios: ScenarioDescriptor[];
     coverage: Record<string, unknown>;
     components: unknown;
-    protocols: string[];
+    protocols: Array<{
+        id: string;
+        label: string;
+        source: string;
+        kind: string;
+        supportedChains: number[];
+    }>;
 }): McpResource[];

package/dist/resources/protocols.d.ts

@@ -1,4 +1,12 @@
-export declare function protocolsResource(protocols: string[]): {
+type ProtocolResourceItem = {
+    id: string;
+    label: string;
+    source: string;
+    kind: string;
+    supportedChains: number[];
+};
+export declare function protocolsResource(protocols: ProtocolResourceItem[]): {
     uri: string;
-    content: string[];
+    content: ProtocolResourceItem[];
 };
+export {};

package/dist/server.d.ts

@@ -1,9 +1,10 @@
 import { type ScenarioDescriptor } from "./tools/scenario.js";
-import type { ExecuteLuaScenarioInput } from "@lunatest/core";
+import { type ExecuteLuaScenarioInput, type PresetRegistry, type ProjectPresetSources } from "@lunatest/core";
+import type { CoverageCatalog } from "@lunatest/contracts";
 type JsonRpcRequest = {
     id: string;
     method: string;
-    params?: Record<string, unknown>;
+    params?: unknown;
 };
 type JsonRpcResponse = {
     id: string;
@@ -19,6 +20,7 @@ type McpServerOptions = {
         covered?: number;
         ratio?: number;
     };
+    coverageCatalog?: Partial<CoverageCatalog>;
     mockState?: Record<string, unknown>;
     componentTree?: Array<{
         name: string;
@@ -29,6 +31,9 @@ type McpServerOptions = {
     componentStates?: Record<string, string[]>;
     protocols?: string[];
     scenarioAdapter?: ExecuteLuaScenarioInput["adapter"];
+    presetRegistry?: PresetRegistry;
+    projectPresetSources?: ProjectPresetSources;
+    projectRoot?: string;
 };
 export declare function createMcpServer(options: McpServerOptions): {
     handleRequest(request: JsonRpcRequest): Promise<JsonRpcResponse>;

package/dist/server.js

@@ -4,27 +4,80 @@ import { createComponentTools } from "./tools/component.js";
 import { createCoverageTools } from "./tools/coverage.js";
 import { createMockTools } from "./tools/mock.js";
 import { createScenarioTools, } from "./tools/scenario.js";
+import { createPresetRegistry, loadProjectPresetSources, } from "@lunatest/core";
+import { isRecord } from "@lunatest/contracts";
 export function createMcpServer(options) {
+    let coverageTools;
     const scenarioTools = createScenarioTools(options.scenarios ?? [], {
         adapter: options.scenarioAdapter,
+        getCoverageSnapshot: async () => coverageTools.report(),
+    });
+    coverageTools = createCoverageTools({
+        seed: options.coverage,
+        getScenarios: scenarioTools.list,
+        coverageCatalog: options.coverageCatalog,
+    });
+    let registryPromise = options.presetRegistry
+        ? Promise.resolve(options.presetRegistry)
+        : null;
+    const resolveRegistry = async () => {
+        if (registryPromise) {
+            return registryPromise;
+        }
+        registryPromise = (async () => {
+            if (options.projectPresetSources) {
+                return createPresetRegistry({
+                    projectSources: options.projectPresetSources,
+                });
+            }
+            if (options.projectRoot) {
+                const projectSources = await loadProjectPresetSources(options.projectRoot);
+                return createPresetRegistry({
+                    projectSources,
+                });
+            }
+            return createPresetRegistry();
+        })();
+        return registryPromise;
+    };
+    const mockTools = createMockTools(options.mockState, {
+        getRegistry: resolveRegistry,
+    });
+    const componentTools = createComponentTools(options.componentTree ?? [], options.componentStates ?? {}, {
+        getScenarios: scenarioTools.list,
+        coverageCatalog: options.coverageCatalog,
     });
-    const coverageTools = createCoverageTools(options.coverage);
-    const mockTools = createMockTools(options.mockState);
-    const componentTools = createComponentTools(options.componentTree ?? [], options.componentStates ?? {});
     const prompts = createPromptCatalog();
     const getResources = async () => {
         const scenarios = await scenarioTools.list();
         const coverage = await coverageTools.report();
         const components = await componentTools.tree();
+        const protocols = await mockTools.listProtocolPresets();
         return createResourceCatalog({
             scenarios,
             coverage,
             components,
-            protocols: options.protocols ?? ["uniswap_v2", "uniswap_v3", "curve", "aave"],
+            protocols: options.protocols?.map((id) => ({
+                id,
+                label: id,
+                source: "custom",
+                kind: "custom",
+                supportedChains: [],
+            })) ??
+                protocols.map((preset) => ({
+                    id: preset.qualifiedId,
+                    label: preset.label,
+                    source: preset.source,
+                    kind: preset.kind,
+                    supportedChains: preset.supportedChains,
+                })),
         });
     };
     return {
         async handleRequest(request) {
+            const params = isRecord(request.params)
+                ? request.params
+                : undefined;
             try {
                 if (request.method === "scenario.list") {
                     return {
@@ -35,22 +88,22 @@ export function createMcpServer(options) {
                 if (request.method === "scenario.get") {
                     return {
                         id: request.id,
-                        result: await scenarioTools.get(String(request.params?.id ?? "")),
+                        result: await scenarioTools.get(String(params?.id ?? "")),
                     };
                 }
                 if (request.method === "scenario.create") {
                     return {
                         id: request.id,
                         result: await scenarioTools.create({
-                            id: request.params?.id === undefined
+                            id: params?.id === undefined
                                 ? undefined
-                                : String(request.params.id),
-                            name: request.params?.name === undefined
+                                : String(params.id),
+                            name: params?.name === undefined
                                 ? undefined
-                                : String(request.params.name),
-                            lua: request.params?.lua === undefined
+                                : String(params.name),
+                            lua: params?.lua === undefined
                                 ? undefined
-                                : String(request.params.lua),
+                                : String(params.lua),
                         }),
                     };
                 }
@@ -58,31 +111,31 @@ export function createMcpServer(options) {
                     return {
                         id: request.id,
                         result: await scenarioTools.run({
-                            id: request.params?.id === undefined
+                            id: params?.id === undefined
                                 ? undefined
-                                : String(request.params.id),
-                            lua: request.params?.lua === undefined
+                                : String(params.id),
+                            lua: params?.lua === undefined
                                 ? undefined
-                                : String(request.params.lua),
+                                : String(params.lua),
                         }),
                     };
                 }
                 if (request.method === "scenario.runAll") {
                     return {
                         id: request.id,
-                        result: await scenarioTools.runAll(request.params?.filter === undefined
+                        result: await scenarioTools.runAll(params?.filter === undefined
                             ? undefined
-                            : String(request.params.filter)),
+                            : String(params.filter)),
                     };
                 }
                 if (request.method === "scenario.mutate") {
                     return {
                         id: request.id,
                         result: await scenarioTools.mutate({
-                            id: String(request.params?.id ?? ""),
-                            count: request.params?.count === undefined
+                            id: String(params?.id ?? ""),
+                            count: params?.count === undefined
                                 ? undefined
-                                : Number(request.params.count),
+                                : Number(params.count),
                         }),
                     };
                 }
@@ -113,19 +166,19 @@ export function createMcpServer(options) {
                 if (request.method === "mock.setState") {
                     return {
                         id: request.id,
-                        result: await mockTools.setState(request.params?.state ?? {}),
+                        result: await mockTools.setState(params?.state ?? {}),
                     };
                 }
                 if (request.method === "state.patch") {
                     return {
                         id: request.id,
-                        result: await mockTools.patchState(request.params?.state ?? {}),
+                        result: await mockTools.patchState(params?.state ?? {}),
                     };
                 }
                 if (request.method === "mock.routes.set") {
                     return {
                         id: request.id,
-                        result: await mockTools.setRoutes(request.params?.routes ?? []),
+                        result: await mockTools.setRoutes(params?.routes ?? []),
                     };
                 }
                 if (request.method === "mock.routes.get") {
@@ -140,6 +193,54 @@ export function createMcpServer(options) {
                         result: await mockTools.listPresets(),
                     };
                 }
+                if (request.method === "mock.listProtocolPresets") {
+                    return {
+                        id: request.id,
+                        result: await mockTools.listProtocolPresets(),
+                    };
+                }
+                if (request.method === "mock.listPresetDiagnostics") {
+                    return {
+                        id: request.id,
+                        result: await mockTools.listPresetDiagnostics(),
+                    };
+                }
+                if (request.method === "mock.getPresetDiagnostic") {
+                    return {
+                        id: request.id,
+                        result: await mockTools.getPresetDiagnostic(String(params?.code ?? "")),
+                    };
+                }
+                if (request.method === "mock.getProtocolPreset") {
+                    return {
+                        id: request.id,
+                        result: await mockTools.getProtocolPreset(String(params?.id ?? "")),
+                    };
+                }
+                if (request.method === "mock.applyProtocolPreset") {
+                    return {
+                        id: request.id,
+                        result: await mockTools.applyProtocolPreset(String(params?.id ?? ""), params?.params ?? {}),
+                    };
+                }
+                if (request.method === "mock.listWalletPresets") {
+                    return {
+                        id: request.id,
+                        result: await mockTools.listWalletPresets(),
+                    };
+                }
+                if (request.method === "mock.getWalletPreset") {
+                    return {
+                        id: request.id,
+                        result: await mockTools.getWalletPreset(String(params?.id ?? "")),
+                    };
+                }
+                if (request.method === "mock.applyWalletPreset") {
+                    return {
+                        id: request.id,
+                        result: await mockTools.applyWalletPreset(String(params?.id ?? ""), params?.params ?? {}),
+                    };
+                }
                 if (request.method === "component.tree") {
                     return {
                         id: request.id,
@@ -149,7 +250,7 @@ export function createMcpServer(options) {
                 if (request.method === "component.states") {
                     return {
                         id: request.id,
-                        result: await componentTools.states(String(request.params?.name ?? "")),
+                        result: await componentTools.states(String(params?.name ?? "")),
                     };
                 }
                 if (request.method === "resource.list") {
@@ -160,7 +261,7 @@ export function createMcpServer(options) {
                     };
                 }
                 if (request.method === "resource.get") {
-                    const target = String(request.params?.uri ?? "");
+                    const target = String(params?.uri ?? "");
                     const resources = await getResources();
                     return {
                         id: request.id,
@@ -174,12 +275,12 @@ export function createMcpServer(options) {
                     };
                 }
                 if (request.method === "prompt.get") {
-                    const target = String(request.params?.id ?? "");
+                    const target = String(params?.id ?? "");
                     const prompt = prompts.find((item) => item.id === target);
                     if (!prompt) {
                         throw new Error(`Prompt not found: ${target}`);
                     }
-                    const input = request.params?.input;
+                    const input = params?.input;
                     const normalizedInput = input === undefined || input === null ? "" : input;
                     return {
                         id: request.id,

package/dist/tools/component.d.ts

@@ -1,10 +1,23 @@
+import type { CoverageCatalog, CoverageMetadata } from "@lunatest/contracts";
 type ComponentStateMap = Record<string, string[]>;
 type ComponentNode = {
     name: string;
     children?: ComponentNode[];
 };
-export declare function createComponentTools(tree?: ComponentNode[], states?: ComponentStateMap): {
+type ScenarioCoverageLike = {
+    name: string;
+    lua?: string;
+    coverage?: CoverageMetadata;
+};
+export declare function createComponentTools(tree?: ComponentNode[], states?: ComponentStateMap, options?: {
+    getScenarios?: () => Promise<ScenarioCoverageLike[]> | ScenarioCoverageLike[];
+    coverageCatalog?: Partial<CoverageCatalog>;
+}): {
     tree(): Promise<ComponentNode[]>;
-    states(name: string): Promise<string[]>;
+    states(name: string): Promise<{
+        known: string[];
+        covered: string[];
+        missing: string[];
+    }>;
 };
 export {};

package/dist/tools/component.js

@@ -1,10 +1,50 @@
-export function createComponentTools(tree = [], states = {}) {
+import { loadLunaConfig, resolveCoverageMetadata } from "@lunatest/core";
+export function createComponentTools(tree = [], states = {}, options = {}) {
+    const resolveCoverage = async () => {
+        if (!options.getScenarios) {
+            return {
+                known: options.coverageCatalog?.components ?? [],
+                covered: [],
+                missing: options.coverageCatalog?.components ?? [],
+            };
+        }
+        const scenarios = await options.getScenarios();
+        const covered = new Set();
+        for (const scenario of scenarios) {
+            const metadata = scenario.coverage ??
+                (scenario.lua
+                    ? resolveCoverageMetadata(await loadLunaConfig(scenario.lua))
+                    : { components: [] });
+            for (const component of metadata.components ?? []) {
+                covered.add(component);
+            }
+        }
+        const known = new Set([
+            ...(options.coverageCatalog?.components ?? []),
+            ...Object.keys(states),
+            ...covered,
+        ]);
+        return {
+            known: Array.from(known).sort(),
+            covered: Array.from(covered).sort(),
+            missing: Array.from(known).filter((item) => !covered.has(item)),
+        };
+    };
     return {
         async tree() {
             return tree;
         },
         async states(name) {
-            return states[name] ?? [];
+            const resolved = await resolveCoverage();
+            const known = Array.from(new Set([
+                ...(states[name] ?? []),
+                ...(resolved.known.includes(name) ? [name] : []),
+            ])).sort();
+            return {
+                known,
+                covered: resolved.covered.includes(name) ? [name] : [],
+                missing: resolved.missing.includes(name) ? [name] : [],
+            };
         },
     };
 }

package/dist/tools/coverage.d.ts

@@ -1,16 +1,26 @@
-export type CoverageReport = {
-    total: number;
-    covered: number;
-    ratio: number;
+import type { CoverageCatalog, CoverageMetadata, CoverageSnapshot } from "@lunatest/contracts";
+type ScenarioCoverageLike = {
+    id: string;
+    name: string;
+    lua?: string;
+    coverage?: CoverageMetadata;
 };
-export declare function createCoverageTools(seed?: Partial<CoverageReport>): {
-    report(): Promise<CoverageReport>;
-    gaps(): Promise<{
-        id: string;
-        reason: string;
-    }[]>;
+export type CoverageGap = {
+    kind: "feature" | "state" | "component";
+    id: string;
+    reason: "scenario not covered";
+};
+export declare function createCoverageTools(options?: {
+    seed?: Partial<CoverageSnapshot>;
+    getScenarios?: () => Promise<ScenarioCoverageLike[]> | ScenarioCoverageLike[];
+    coverageCatalog?: Partial<CoverageCatalog>;
+}): {
+    report(): Promise<CoverageSnapshot>;
+    gaps(): Promise<CoverageGap[]>;
     suggest(): Promise<{
         id: string;
         title: string;
+        target: CoverageGap;
     }[]>;
 };
+export {};

package/dist/tools/coverage.js

@@ -1,28 +1,83 @@
-export function createCoverageTools(seed) {
-    const report = {
-        total: seed?.total ?? 0,
-        covered: seed?.covered ?? 0,
-        ratio: seed?.ratio ??
-            ((seed?.total ?? 0) === 0
-                ? 1
-                : Number(((seed?.covered ?? 0) / (seed?.total ?? 0)).toFixed(4))),
+import { buildCoverageSnapshot, loadLunaConfig, resolveCoverageMetadata, } from "@lunatest/core";
+export function createCoverageTools(options = {}) {
+    const seed = {
+        total: options.seed?.total ?? 0,
+        covered: options.seed?.covered ?? 0,
+        ratio: options.seed?.ratio ?? 1,
+        known: options.seed?.known ?? { features: [], states: [], components: [] },
+        coveredTargets: options.seed?.coveredTargets ?? { features: [], states: [], components: [] },
+        missing: options.seed?.missing ?? { features: [], states: [], components: [] },
+    };
+    const resolveReport = async () => {
+        if (!options.getScenarios) {
+            return seed;
+        }
+        const scenarios = await options.getScenarios();
+        if (scenarios.length === 0) {
+            return seed;
+        }
+        const items = await Promise.all(scenarios.map(async (scenario) => {
+            if (scenario.coverage) {
+                return {
+                    coverage: scenario.coverage,
+                };
+            }
+            if (!scenario.lua) {
+                return {
+                    coverage: {},
+                };
+            }
+            const config = await loadLunaConfig(scenario.lua);
+            return {
+                ...config,
+                coverage: resolveCoverageMetadata(config),
+            };
+        }));
+        return buildCoverageSnapshot({
+            items,
+            coverageCatalog: options.coverageCatalog,
+        });
+    };
+    const toGaps = (report) => {
+        const explicit = [
+            ...report.missing.features.map((id) => ({
+                kind: "feature",
+                id,
+                reason: "scenario not covered",
+            })),
+            ...report.missing.states.map((id) => ({
+                kind: "state",
+                id,
+                reason: "scenario not covered",
+            })),
+            ...report.missing.components.map((id) => ({
+                kind: "component",
+                id,
+                reason: "scenario not covered",
+            })),
+        ];
+        if (explicit.length > 0) {
+            return explicit;
+        }
+        const fallbackMissing = Math.max(0, report.total - report.covered);
+        return Array.from({ length: fallbackMissing }, (_, index) => ({
+            kind: "feature",
+            id: `gap-${index + 1}`,
+            reason: "scenario not covered",
+        }));
     };
     return {
         async report() {
-            return report;
+            return resolveReport();
         },
         async gaps() {
-            const missing = Math.max(0, report.total - report.covered);
-            return Array.from({ length: missing }, (_, index) => ({
-                id: `gap-${index + 1}`,
-                reason: "scenario not covered",
-            }));
+            return toGaps(await resolveReport());
         },
         async suggest() {
-            const missing = Math.max(0, report.total - report.covered);
-            return Array.from({ length: missing }, (_, index) => ({
+            return toGaps(await resolveReport()).map((gap, index) => ({
                 id: `suggestion-${index + 1}`,
-                title: `Add edge case scenario ${index + 1}`,
+                title: `Add scenario for ${gap.kind}:${gap.id}`,
+                target: gap,
             }));
         },
     };

package/dist/tools/mock.d.ts

@@ -1,8 +1,24 @@
-export declare function createMockTools(initialState?: Record<string, unknown>): {
+import { type PresetDiagnostic, type ProtocolPresetCatalogEntry, type ProtocolPresetMaterialization, type WalletPresetCatalogEntry, type WalletPresetMaterialization } from "@lunatest/contracts";
+import { type PresetRegistry, type ProjectPresetSources } from "@lunatest/core";
+type CreateMockToolsOptions = {
+    registry?: PresetRegistry;
+    projectPresetSources?: ProjectPresetSources;
+    getRegistry?: () => Promise<PresetRegistry>;
+};
+export declare function createMockTools(initialState?: Record<string, unknown>, options?: CreateMockToolsOptions): {
     getState(): Promise<Record<string, unknown>>;
     setState(next: Record<string, unknown>): Promise<Record<string, unknown>>;
     patchState(partial: Record<string, unknown>): Promise<Record<string, unknown>>;
     setRoutes(nextRoutes: Array<Record<string, unknown>>): Promise<Record<string, unknown>[]>;
     getRoutes(): Promise<Record<string, unknown>[]>;
     listPresets(): Promise<string[]>;
+    listPresetDiagnostics(): Promise<PresetDiagnostic[]>;
+    getPresetDiagnostic(code: string): Promise<PresetDiagnostic | null>;
+    listProtocolPresets(): Promise<ProtocolPresetCatalogEntry[]>;
+    getProtocolPreset(id: string): Promise<ProtocolPresetCatalogEntry | null>;
+    applyProtocolPreset(id: string, params?: Record<string, unknown>): Promise<ProtocolPresetMaterialization>;
+    listWalletPresets(): Promise<WalletPresetCatalogEntry[]>;
+    getWalletPreset(id: string): Promise<WalletPresetCatalogEntry | null>;
+    applyWalletPreset(id: string, params?: Record<string, unknown>): Promise<WalletPresetMaterialization>;
 };
+export {};

package/dist/tools/mock.js

@@ -1,8 +1,22 @@
-import { deepClone, deepMerge } from "@lunatest/contracts";
-export function createMockTools(initialState = {}) {
+import { deepClone, deepMerge, } from "@lunatest/contracts";
+import { createPresetRegistry, getPresetDiagnostics as coreGetPresetDiagnostics, getProtocolPreset as coreGetProtocolPreset, getWalletPreset as coreGetWalletPreset, listProtocolPresets as coreListProtocolPresets, listWalletPresets as coreListWalletPresets, materializeProtocolPreset as coreMaterializeProtocolPreset, materializeWalletPreset as coreMaterializeWalletPreset, } from "@lunatest/core";
+export function createMockTools(initialState = {}, options = {}) {
     let state = deepClone(initialState);
     let routes = [];
-    const presets = ["uniswap_v2", "uniswap_v3", "curve", "aave"];
+    let cachedRegistry = options.registry ?? null;
+    const resolveRegistry = async () => {
+        if (cachedRegistry) {
+            return cachedRegistry;
+        }
+        if (options.getRegistry) {
+            cachedRegistry = await options.getRegistry();
+            return cachedRegistry;
+        }
+        cachedRegistry = createPresetRegistry({
+            projectSources: options.projectPresetSources,
+        });
+        return cachedRegistry;
+    };
     return {
         async getState() {
             return deepClone(state);
@@ -23,7 +37,42 @@ export function createMockTools(initialState = {}) {
             return deepClone(routes);
         },
         async listPresets() {
-            return [...presets];
+            return (await coreListProtocolPresets(await resolveRegistry())).map((preset) => preset.qualifiedId);
+        },
+        async listPresetDiagnostics() {
+            return coreGetPresetDiagnostics(await resolveRegistry());
+        },
+        async getPresetDiagnostic(code) {
+            const diagnostics = await coreGetPresetDiagnostics(await resolveRegistry());
+            return diagnostics.find((item) => item.code === code) ?? null;
+        },
+        async listProtocolPresets() {
+            return coreListProtocolPresets(await resolveRegistry());
+        },
+        async getProtocolPreset(id) {
+            return coreGetProtocolPreset(id, await resolveRegistry());
+        },
+        async applyProtocolPreset(id, params = {}) {
+            const materialized = await coreMaterializeProtocolPreset(id, params, await resolveRegistry());
+            state = deepMerge(state, {
+                walletSession: materialized.walletSession,
+                ...materialized.interceptState,
+            });
+            routes = deepClone(materialized.routeMocks);
+            return materialized;
+        },
+        async listWalletPresets() {
+            return coreListWalletPresets(await resolveRegistry());
+        },
+        async getWalletPreset(id) {
+            return coreGetWalletPreset(id, await resolveRegistry());
+        },
+        async applyWalletPreset(id, params = {}) {
+            const materialized = await coreMaterializeWalletPreset(id, params, await resolveRegistry());
+            state = deepMerge(state, {
+                walletSession: materialized.walletSession,
+            });
+            return materialized;
         },
     };
 }

package/dist/tools/scenario.d.ts

@@ -1,15 +1,18 @@
 import { type ExecuteLuaScenarioInput } from "@lunatest/core";
+import type { CoverageMetadata, CoverageSnapshot } from "@lunatest/contracts";
 export type ScenarioDescriptor = {
     id: string;
     name: string;
     lua?: string;
     tags?: string[];
+    coverage?: CoverageMetadata;
 };
 type ScenarioCreateInput = {
     id?: string;
     name?: string;
     lua?: string;
     tags?: string[];
+    coverage?: CoverageMetadata;
 };
 type ScenarioMutateInput = {
     id: string;
@@ -39,6 +42,7 @@ export type ScenarioTools = {
 };
 type CreateScenarioToolsOptions = {
     adapter?: ExecuteLuaScenarioInput["adapter"];
+    getCoverageSnapshot?: () => Promise<CoverageSnapshot>;
 };
 export declare function createScenarioTools(seed: ScenarioDescriptor[], options?: CreateScenarioToolsOptions): ScenarioTools;
 export {};

package/dist/tools/scenario.js

@@ -1,5 +1,5 @@
 import { mutateScenarioVariants } from "../generation/mutator.js";
-import { executeLuaScenario } from "@lunatest/core";
+import { executeLuaScenario, loadLunaConfig, resolveCoverageMetadata } from "@lunatest/core";
 async function runLua(source, adapter) {
     const execution = await executeLuaScenario({
         source,
@@ -23,11 +23,14 @@ export function createScenarioTools(seed, options = {}) {
         async create(input) {
             const nextId = input.id && input.id.length > 0 ? input.id : `scenario-${store.size + 1}`;
             const nextName = input.name && input.name.length > 0 ? input.name : `scenario ${store.size + 1}`;
+            const coverage = input.coverage ??
+                (input.lua ? resolveCoverageMetadata(await loadLunaConfig(input.lua)) : undefined);
             const next = {
                 id: nextId,
                 name: nextName,
                 lua: input.lua,
                 tags: input.tags,
+                coverage,
             };
             store.set(next.id, next);
             return next;
@@ -86,7 +89,12 @@ export function createScenarioTools(seed, options = {}) {
                 throw new Error(`Scenario not found: ${input.id}`);
             }
             const count = Math.max(1, Math.trunc(input.count ?? 1));
-            const variants = mutateScenarioVariants(source, count);
+            const coverageSnapshot = options.getCoverageSnapshot
+                ? await options.getCoverageSnapshot()
+                : undefined;
+            const variants = mutateScenarioVariants(source, count, {
+                missingTargets: coverageSnapshot?.missing,
+            });
             for (const variant of variants) {
                 store.set(variant.id, variant);
             }

package/dist/transport/stdio.d.ts

@@ -1,12 +1,12 @@
 import type { createMcpServer } from "../server.js";
 type McpServer = ReturnType<typeof createMcpServer>;
 type JsonRpcLikeRequest = {
-    id: string;
+    id?: string | number | null;
     method: string;
-    params?: Record<string, unknown>;
+    params?: unknown;
 };
 type JsonRpcLikeResponse = {
-    id: string;
+    id: string | number | null;
     result?: unknown;
     error?: {
         message: string;

package/dist/transport/stdio.js

@@ -28,16 +28,14 @@ export function parseJsonRpcLine(rawLine) {
     }
     const id = parsed.id;
     const method = parsed.method;
-    if (typeof id !== "string" || typeof method !== "string") {
-        return invalidRequestResponse("JSON-RPC request requires string id and method");
+    if (typeof method !== "string" ||
+        (id !== undefined && id !== null && typeof id !== "string" && typeof id !== "number")) {
+        return invalidRequestResponse("JSON-RPC request requires method and optional string|number|null id");
     }
-    const params = parsed.params !== undefined && isRecord(parsed.params)
-        ? parsed.params
-        : undefined;
     return {
         id,
         method,
-        params,
+        params: parsed.params,
     };
 }
 export async function processJsonRpcLine(line, server) {
@@ -45,7 +43,18 @@ export async function processJsonRpcLine(line, server) {
     if (!isJsonRpcLikeRequest(parsed)) {
         return parsed;
     }
-    return server.handleRequest(parsed);
+    const response = await server.handleRequest({
+        id: parsed.id === undefined ? "__notification__" : String(parsed.id),
+        method: parsed.method,
+        params: parsed.params,
+    });
+    if (parsed.id === undefined) {
+        return null;
+    }
+    return {
+        ...response,
+        id: parsed.id,
+    };
 }
 export async function runStdioServer(options) {
     const rl = createInterface({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunatest/mcp",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "private": false,
   "type": "module",
   "bin": {
@@ -24,12 +24,17 @@
     "dist"
   ],
   "dependencies": {
-    "@lunatest/core": "0.1.0",
-    "@lunatest/contracts": "0.1.0"
+    "@lunatest/contracts": "0.1.0",
+    "@lunatest/core": "0.1.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/songforthemute/lunatest",
+    "directory": "packages/mcp"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "test": "vitest run",
-    "lint": "tsc -p tsconfig.json --noEmit"
+    "lint": "tsc -p tsconfig.lint.json --pretty false"
   }
 }