@jshookmcp/jshook 0.2.6 → 0.2.7

package/dist/src/server/domains/trace/handlers.d.ts

@@ -1,17 +0,0 @@
-import type { MCPServerContext } from '../../MCPServer.context.js';
-import { type TraceRecorder } from '../../../modules/trace/TraceRecorder.js';
-export declare class TraceToolHandlers {
-    private readonly recorder;
-    private readonly ctx;
-    constructor(recorder: TraceRecorder, ctx: MCPServerContext);
-    handleStartTraceRecording(args: Record<string, unknown>): Promise<unknown>;
-    handleStopTraceRecording(): Promise<unknown>;
-    handleQueryTraceSql(args: Record<string, unknown>): Promise<unknown>;
-    handleSeekToTimestamp(args: Record<string, unknown>): Promise<unknown>;
-    handleDiffHeapSnapshots(args: Record<string, unknown>): Promise<unknown>;
-    handleExportTrace(args: Record<string, unknown>): Promise<unknown>;
-    private getDbForReading;
-    private rowToObject;
-    private safeParseJSON;
-    handleSummarizeTrace(args: Record<string, unknown>): Promise<unknown>;
-}

package/dist/src/server/domains/trace/handlers.js

@@ -1,353 +0,0 @@
-import { writeFile } from 'node:fs/promises';
-import { TraceDB } from '../../../modules/trace/TraceDB.js';
-import {} from '../../../modules/trace/TraceRecorder.js';
-import { resolveArtifactPath } from '../../../utils/artifacts.js';
-import { summarizeEvents, summarizeMemoryDeltas, } from '../../domains/trace/TraceSummarizer.js';
-export class TraceToolHandlers {
-    recorder;
-    ctx;
-    constructor(recorder, ctx) {
-        this.recorder = recorder;
-        this.ctx = ctx;
-    }
-    async handleStartTraceRecording(args) {
-        const cdpDomains = args['cdpDomains'];
-        const recordMemoryDeltas = args['recordMemoryDeltas'];
-        const eventBus = this.ctx.eventBus;
-        if (!eventBus) {
-            throw new Error('EventBus not available on server context');
-        }
-        let cdpSession = null;
-        try {
-            if (this.ctx.collector) {
-                const page = await this.ctx.collector.getActivePage();
-                const pageAny = page;
-                if (typeof pageAny.createCDPSession === 'function') {
-                    cdpSession = await pageAny.createCDPSession();
-                }
-            }
-        }
-        catch {
-        }
-        const session = await this.recorder.start(eventBus, cdpSession, {
-            cdpDomains,
-            recordMemoryDeltas: recordMemoryDeltas ?? true,
-        });
-        return {
-            status: 'recording',
-            sessionId: session.sessionId,
-            dbPath: session.dbPath,
-            message: `Recording started. CDP session: ${cdpSession ? 'active' : 'not available'}`,
-        };
-    }
-    async handleStopTraceRecording() {
-        const session = this.recorder.stop();
-        const duration = session.stoppedAt ? session.stoppedAt - session.startedAt : 0;
-        return {
-            status: 'stopped',
-            sessionId: session.sessionId,
-            dbPath: session.dbPath,
-            eventCount: session.eventCount,
-            memoryDeltaCount: session.memoryDeltaCount,
-            heapSnapshotCount: session.heapSnapshotCount,
-            durationMs: duration,
-            message: `Recording stopped. ${session.eventCount} events, ${session.memoryDeltaCount} memory deltas, ${session.heapSnapshotCount} heap snapshots recorded.`,
-        };
-    }
-    async handleQueryTraceSql(args) {
-        const sql = args['sql'];
-        const dbPath = args['dbPath'];
-        if (!sql) {
-            throw new Error('sql parameter is required');
-        }
-        let result;
-        let tempDb = null;
-        try {
-            if (dbPath) {
-                tempDb = new TraceDB({ dbPath });
-                result = tempDb.query(sql);
-            }
-            else {
-                const activeDb = this.recorder.getDB();
-                if (!activeDb) {
-                    throw new Error('No active recording and no dbPath specified. Start a recording or provide a dbPath.');
-                }
-                activeDb.flush();
-                result = activeDb.query(sql);
-            }
-            return {
-                columns: result.columns,
-                rows: result.rows,
-                rowCount: result.rowCount,
-            };
-        }
-        finally {
-            if (tempDb) {
-                tempDb.close();
-            }
-        }
-    }
-    async handleSeekToTimestamp(args) {
-        const timestamp = args['timestamp'];
-        const dbPath = args['dbPath'];
-        const windowMs = args['windowMs'] ?? 100;
-        if (!timestamp) {
-            throw new Error('timestamp parameter is required');
-        }
-        let tempDb = null;
-        try {
-            const db = this.getDbForReading(dbPath);
-            if (dbPath)
-                tempDb = db;
-            const events = db.getEventsByTimeRange(timestamp - windowMs, timestamp + windowMs);
-            const debuggerEventsResult = db.query(`SELECT * FROM events WHERE category = 'debugger' AND timestamp <= ${timestamp} ORDER BY timestamp DESC LIMIT 5`);
-            const memoryStateResult = db.query(`SELECT m1.* FROM memory_deltas m1
-         INNER JOIN (SELECT address, MAX(timestamp) as max_ts FROM memory_deltas WHERE timestamp <= ${timestamp} GROUP BY address) m2
-         ON m1.address = m2.address AND m1.timestamp = m2.max_ts
-         ORDER BY m1.address`);
-            const networkResult = db.query(`SELECT * FROM events WHERE category = 'network' AND event_type = 'Network.loadingFinished' AND timestamp <= ${timestamp} ORDER BY timestamp DESC LIMIT 20`);
-            const snapshotResult = db.query(`SELECT id, timestamp, summary FROM heap_snapshots WHERE timestamp <= ${timestamp} ORDER BY timestamp DESC LIMIT 1`);
-            return {
-                seekTimestamp: timestamp,
-                windowMs,
-                events: events.map((e) => ({
-                    timestamp: e.timestamp,
-                    category: e.category,
-                    eventType: e.eventType,
-                    data: this.safeParseJSON(e.data),
-                    scriptId: e.scriptId,
-                    lineNumber: e.lineNumber,
-                })),
-                debuggerState: {
-                    recentEvents: debuggerEventsResult.rows.map((row) => this.rowToObject(debuggerEventsResult.columns, row)),
-                },
-                memoryState: {
-                    addressValues: memoryStateResult.rows.map((row) => this.rowToObject(memoryStateResult.columns, row)),
-                },
-                networkState: {
-                    completedRequests: networkResult.rows.map((row) => this.rowToObject(networkResult.columns, row)),
-                },
-                nearestHeapSnapshot: snapshotResult.rows.length > 0
-                    ? this.rowToObject(snapshotResult.columns, snapshotResult.rows[0])
-                    : null,
-            };
-        }
-        finally {
-            if (tempDb)
-                tempDb.close();
-        }
-    }
-    async handleDiffHeapSnapshots(args) {
-        const snapshotId1 = args['snapshotId1'];
-        const snapshotId2 = args['snapshotId2'];
-        const dbPath = args['dbPath'];
-        if (!snapshotId1 || !snapshotId2) {
-            throw new Error('snapshotId1 and snapshotId2 are required');
-        }
-        let tempDb = null;
-        try {
-            const db = this.getDbForReading(dbPath);
-            if (dbPath)
-                tempDb = db;
-            const snap1Result = db.query(`SELECT id, timestamp, summary FROM heap_snapshots WHERE id = ${snapshotId1}`);
-            const snap2Result = db.query(`SELECT id, timestamp, summary FROM heap_snapshots WHERE id = ${snapshotId2}`);
-            if (snap1Result.rowCount === 0) {
-                throw new Error(`Snapshot with id ${snapshotId1} not found`);
-            }
-            if (snap2Result.rowCount === 0) {
-                throw new Error(`Snapshot with id ${snapshotId2} not found`);
-            }
-            const snap1Row = this.rowToObject(snap1Result.columns, snap1Result.rows[0]);
-            const snap2Row = this.rowToObject(snap2Result.columns, snap2Result.rows[0]);
-            const summary1 = this.safeParseJSON(snap1Row['summary']);
-            const summary2 = this.safeParseJSON(snap2Row['summary']);
-            const counts1 = (summary1['objectCounts'] ?? {});
-            const counts2 = (summary2['objectCounts'] ?? {});
-            const allKeys = new Set([...Object.keys(counts1), ...Object.keys(counts2)]);
-            const added = [];
-            const removed = [];
-            const changed = [];
-            for (const key of allKeys) {
-                const c1 = counts1[key] ?? 0;
-                const c2 = counts2[key] ?? 0;
-                if (c1 === 0 && c2 > 0) {
-                    added.push({ name: key, count: c2 });
-                }
-                else if (c1 > 0 && c2 === 0) {
-                    removed.push({ name: key, count: c1 });
-                }
-                else if (c1 !== c2) {
-                    changed.push({ name: key, countBefore: c1, countAfter: c2, delta: c2 - c1 });
-                }
-            }
-            changed.sort((a, b) => Math.abs(b.delta) - Math.abs(a.delta));
-            const totalSize1 = summary1['totalSize'] ?? 0;
-            const totalSize2 = summary2['totalSize'] ?? 0;
-            return {
-                snapshot1: {
-                    id: snap1Row['id'],
-                    timestamp: snap1Row['timestamp'],
-                    totalSize: totalSize1,
-                    nodeCount: summary1['nodeCount'] ?? 0,
-                },
-                snapshot2: {
-                    id: snap2Row['id'],
-                    timestamp: snap2Row['timestamp'],
-                    totalSize: totalSize2,
-                    nodeCount: summary2['nodeCount'] ?? 0,
-                },
-                diff: {
-                    added: added.slice(0, 50),
-                    removed: removed.slice(0, 50),
-                    changed: changed.slice(0, 100),
-                    totalSizeDelta: totalSize2 - totalSize1,
-                    addedCount: added.length,
-                    removedCount: removed.length,
-                    changedCount: changed.length,
-                },
-            };
-        }
-        finally {
-            if (tempDb)
-                tempDb.close();
-        }
-    }
-    async handleExportTrace(args) {
-        const dbPath = args['dbPath'];
-        const outputPath = args['outputPath'];
-        let tempDb = null;
-        try {
-            const db = this.getDbForReading(dbPath);
-            if (dbPath)
-                tempDb = db;
-            const allEvents = db.query('SELECT timestamp, category, event_type, data, script_id, line_number FROM events ORDER BY timestamp ASC');
-            const PAIRED_BEGIN = new Set(['Debugger.paused']);
-            const PAIRED_END = new Set(['Debugger.resumed']);
-            const traceEvents = allEvents.rows.map((row) => {
-                const ts = row[0] * 1000;
-                const cat = row[1];
-                const name = row[2];
-                const dataStr = row[3];
-                let ph = 'i';
-                if (PAIRED_BEGIN.has(name))
-                    ph = 'B';
-                else if (PAIRED_END.has(name))
-                    ph = 'E';
-                return {
-                    name,
-                    cat,
-                    ph,
-                    ts,
-                    pid: 1,
-                    tid: 1,
-                    args: this.safeParseJSON(dataStr),
-                    ...(ph === 'i' ? { s: 'g' } : {}),
-                };
-            });
-            let finalOutputPath;
-            if (outputPath) {
-                finalOutputPath = outputPath;
-            }
-            else {
-                const { absolutePath } = await resolveArtifactPath({
-                    category: 'traces',
-                    toolName: 'trace_export',
-                    ext: 'json',
-                });
-                finalOutputPath = absolutePath;
-            }
-            const output = JSON.stringify(traceEvents, null, 2);
-            await writeFile(finalOutputPath, output, 'utf-8');
-            return {
-                exportedPath: finalOutputPath,
-                eventCount: traceEvents.length,
-                format: 'Chrome Trace Event JSON',
-                message: `Exported ${traceEvents.length} events to ${finalOutputPath}. Open in chrome://tracing or ui.perfetto.dev`,
-            };
-        }
-        finally {
-            if (tempDb)
-                tempDb.close();
-        }
-    }
-    getDbForReading(dbPath) {
-        if (dbPath) {
-            return new TraceDB({ dbPath });
-        }
-        const activeDb = this.recorder.getDB();
-        if (!activeDb) {
-            throw new Error('No active recording and no dbPath specified. Start a recording or provide a dbPath.');
-        }
-        activeDb.flush();
-        return activeDb;
-    }
-    rowToObject(columns, row) {
-        const obj = {};
-        for (let i = 0; i < columns.length; i++) {
-            obj[columns[i]] = row[i];
-        }
-        return obj;
-    }
-    safeParseJSON(str) {
-        try {
-            return JSON.parse(str);
-        }
-        catch {
-            return str;
-        }
-    }
-    async handleSummarizeTrace(args) {
-        const detail = args['detail'] ?? 'balanced';
-        const dbPath = args['dbPath'];
-        let db;
-        let shouldClose = false;
-        if (dbPath) {
-            db = new TraceDB({ dbPath });
-            shouldClose = true;
-        }
-        else if (this.recorder.getState() === 'recording') {
-            const activeDb = this.recorder.getDB();
-            if (!activeDb)
-                throw new Error('Active recording has no database');
-            db = activeDb;
-        }
-        else {
-            throw new Error('No trace database specified and no active recording');
-        }
-        try {
-            const eventsResult = db.query('SELECT timestamp, category, event_type, data, script_id, line_number FROM events ORDER BY timestamp');
-            const events = eventsResult.rows.map((row) => ({
-                timestamp: row[0],
-                category: row[1],
-                eventType: row[2],
-                data: typeof row[3] === 'string' ? this.safeParseJSON(row[3]) : row[3],
-                scriptId: row[4],
-                lineNumber: row[5],
-            }));
-            const deltasResult = db.query('SELECT timestamp, address, old_value, new_value, size, value_type FROM memory_deltas ORDER BY timestamp');
-            const deltas = deltasResult.rows.map((row) => ({
-                timestamp: row[0],
-                address: row[1],
-                oldValue: row[2],
-                newValue: row[3],
-                size: row[4],
-                valueType: row[5],
-            }));
-            const eventSummary = summarizeEvents(events, detail);
-            const memorySummary = summarizeMemoryDeltas(deltas);
-            return {
-                events: eventSummary,
-                memory: memorySummary,
-                metadata: {
-                    dbPath: dbPath ?? 'active recording',
-                    generatedAt: new Date().toISOString(),
-                },
-            };
-        }
-        finally {
-            if (shouldClose) {
-                db.close();
-            }
-        }
-    }
-}

package/dist/src/server/domains/trace/index.d.ts

@@ -1,2 +0,0 @@
-export * from './definitions.tools.js';
-export { TraceToolHandlers } from './handlers.js';

package/dist/src/server/domains/trace/index.js

@@ -1,2 +0,0 @@
-export * from './definitions.tools.js';
-export { TraceToolHandlers } from './handlers.js';

package/dist/src/server/domains/trace/manifest.d.ts

@@ -1,64 +0,0 @@
-import type { MCPServerContext } from '../../domains/shared/registry.js';
-import { TraceToolHandlers } from '../../domains/trace/handlers.js';
-type H = TraceToolHandlers;
-declare function ensure(ctx: MCPServerContext): H;
-declare const manifest: {
-    kind: "domain-manifest";
-    version: 1;
-    domain: "trace";
-    depKey: "traceHandlers";
-    profiles: ("workflow" | "full")[];
-    ensure: typeof ensure;
-    prerequisites: {};
-    workflowRule: {
-        patterns: RegExp[];
-        priority: number;
-        tools: string[];
-        hint: string;
-    };
-    registrations: {
-        tool: {
-            inputSchema: {
-                [x: string]: unknown;
-                type: "object";
-                properties?: {
-                    [x: string]: object;
-                } | undefined;
-                required?: string[] | undefined;
-            };
-            name: string;
-            description?: string | undefined;
-            outputSchema?: {
-                [x: string]: unknown;
-                type: "object";
-                properties?: {
-                    [x: string]: object;
-                } | undefined;
-                required?: string[] | undefined;
-            } | undefined;
-            annotations?: {
-                title?: string | undefined;
-                readOnlyHint?: boolean | undefined;
-                destructiveHint?: boolean | undefined;
-                idempotentHint?: boolean | undefined;
-                openWorldHint?: boolean | undefined;
-            } | undefined;
-            execution?: {
-                taskSupport?: "optional" | "required" | "forbidden" | undefined;
-            } | undefined;
-            _meta?: {
-                [x: string]: unknown;
-            } | undefined;
-            icons?: {
-                src: string;
-                mimeType?: string | undefined;
-                sizes?: string[] | undefined;
-                theme?: "light" | "dark" | undefined;
-            }[] | undefined;
-            title?: string | undefined;
-        };
-        domain: "trace";
-        bind: (deps: import("../../domains/shared/registry.js").ToolHandlerDeps) => (args: import("../../types.js").ToolArgs) => Promise<unknown>;
-    }[];
-};
-export default manifest;

package/dist/src/server/domains/trace/manifest.js

@@ -1,62 +0,0 @@
-import { bindByDepKey, toolLookup } from '../../domains/shared/registry.js';
-import { TRACE_TOOLS } from '../../domains/trace/definitions.tools.js';
-import { TraceToolHandlers } from '../../domains/trace/handlers.js';
-import { TraceRecorder } from '../../../modules/trace/TraceRecorder.js';
-const DOMAIN = 'trace';
-const DEP_KEY = 'traceHandlers';
-const t = toolLookup(TRACE_TOOLS);
-const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
-function ensure(ctx) {
-    if (!ctx.traceRecorder) {
-        ctx.traceRecorder = new TraceRecorder();
-    }
-    if (!ctx.traceHandlers) {
-        ctx.traceHandlers = new TraceToolHandlers(ctx.traceRecorder, ctx);
-    }
-    return ctx.traceHandlers;
-}
-const manifest = {
-    kind: 'domain-manifest',
-    version: 1,
-    domain: DOMAIN,
-    depKey: DEP_KEY,
-    profiles: ['workflow', 'full'],
-    ensure,
-    prerequisites: {},
-    workflowRule: {
-        patterns: [/trace/i, /time.?travel/i, /replay/i, /recorded?\s+events?/i],
-        priority: 70,
-        tools: [
-            'start_trace_recording',
-            'stop_trace_recording',
-            'query_trace_sql',
-            'seek_to_timestamp',
-            'diff_heap_snapshots',
-            'export_trace',
-            'summarize_trace',
-        ],
-        hint: 'Start recording → perform actions → stop recording → summarize/query/seek/diff/export',
-    },
-    registrations: [
-        {
-            tool: t('start_trace_recording'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleStartTraceRecording(a)),
-        },
-        {
-            tool: t('stop_trace_recording'),
-            domain: DOMAIN,
-            bind: b((h) => h.handleStopTraceRecording()),
-        },
-        { tool: t('query_trace_sql'), domain: DOMAIN, bind: b((h, a) => h.handleQueryTraceSql(a)) },
-        { tool: t('seek_to_timestamp'), domain: DOMAIN, bind: b((h, a) => h.handleSeekToTimestamp(a)) },
-        {
-            tool: t('diff_heap_snapshots'),
-            domain: DOMAIN,
-            bind: b((h, a) => h.handleDiffHeapSnapshots(a)),
-        },
-        { tool: t('export_trace'), domain: DOMAIN, bind: b((h, a) => h.handleExportTrace(a)) },
-        { tool: t('summarize_trace'), domain: DOMAIN, bind: b((h, a) => h.handleSummarizeTrace(a)) },
-    ],
-};
-export default manifest;

package/dist/src/server/domains/transform/definitions.d.ts

@@ -1,2 +0,0 @@
-import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-export declare const transformTools: Tool[];

package/dist/src/server/domains/transform/definitions.js

@@ -1,52 +0,0 @@
-import { tool } from '../../registry/tool-builder.js';
-const transformsEnum = [
-    'constant_fold',
-    'string_decrypt',
-    'dead_code_remove',
-    'control_flow_flatten',
-    'rename_vars',
-];
-export const transformTools = [
-    tool('ast_transform_preview')
-        .desc('Preview lightweight AST-like transforms (string/regex based) and return before/after diff.')
-        .string('code', 'Source code to transform.')
-        .array('transforms', { type: 'string', enum: transformsEnum }, 'Ordered transform list.')
-        .boolean('preview', 'Whether to generate line diff output.', { default: true })
-        .required('code', 'transforms')
-        .build(),
-    tool('ast_transform_chain')
-        .desc('Create and store an in-memory transform chain.')
-        .string('name', 'Chain name.')
-        .array('transforms', { type: 'string', enum: transformsEnum }, 'Ordered transform list.')
-        .string('description', 'Optional chain description.')
-        .required('name', 'transforms')
-        .build(),
-    tool('ast_transform_apply')
-        .desc('Apply transforms to input code or a live page scriptId.')
-        .string('scriptId', 'Target script ID from page debugger context.')
-        .string('code', 'Direct source code input.')
-        .string('chainName', 'Use a saved transform chain by name.')
-        .array('transforms', { type: 'string', enum: transformsEnum }, 'Direct transform list (used when chainName is not provided).')
-        .build(),
-    tool('crypto_extract_standalone')
-        .desc('Extract crypto/sign/encrypt function from current page and generate standalone runnable code.')
-        .string('targetFunction', 'Target function name/path, e.g. "window.sign".')
-        .boolean('includePolyfills', 'Include minimal runtime polyfills.', { default: true })
-        .required('targetFunction')
-        .build(),
-    tool('crypto_test_harness')
-        .desc('Run extracted crypto code in worker_threads + vm sandbox and return deterministic test results.')
-        .string('code', 'Standalone function code.')
-        .string('functionName', 'Exported function name to execute.')
-        .array('testInputs', { type: 'string' }, 'Input list for test execution.')
-        .required('code', 'functionName', 'testInputs')
-        .build(),
-    tool('crypto_compare')
-        .desc('Compare two crypto implementations against identical test vectors.')
-        .string('code1', 'Implementation A code.')
-        .string('code2', 'Implementation B code.')
-        .string('functionName', 'Function name shared by both implementations.')
-        .array('testInputs', { type: 'string' }, 'Input list for comparison.')
-        .required('code1', 'code2', 'functionName', 'testInputs')
-        .build(),
-];

package/dist/src/server/domains/transform/handlers.d.ts

@@ -1 +0,0 @@
-export { TransformToolHandlers } from '../../domains/transform/handlers.impl.core.js';

package/dist/src/server/domains/transform/handlers.impl.core.d.ts

@@ -1,21 +0,0 @@
-import { TransformToolHandlersCrypto } from '../../domains/transform/handlers.impl.transform-crypto.js';
-export declare class TransformToolHandlers extends TransformToolHandlersCrypto {
-    handleAstTransformPreview(args: Record<string, unknown>): Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-    handleAstTransformChain(args: Record<string, unknown>): Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-    handleAstTransformApply(args: Record<string, unknown>): Promise<{
-        content: {
-            type: "text";
-            text: string;
-        }[];
-    }>;
-}

package/dist/src/server/domains/transform/handlers.impl.core.js

@@ -1,75 +0,0 @@
-import { TransformToolHandlersCrypto } from '../../domains/transform/handlers.impl.transform-crypto.js';
-export class TransformToolHandlers extends TransformToolHandlersCrypto {
-    async handleAstTransformPreview(args) {
-        try {
-            const code = this.requireString(args.code, 'code');
-            const transforms = this.parseTransforms(args.transforms);
-            const preview = this.parseBoolean(args.preview, true);
-            const result = this.applyTransforms(code, transforms);
-            const diff = preview ? this.buildDiff(code, result.transformed) : '';
-            return this.toTextResponse({
-                original: code,
-                transformed: result.transformed,
-                diff,
-                appliedTransforms: result.appliedTransforms,
-            });
-        }
-        catch (error) {
-            return this.fail('ast_transform_preview', error);
-        }
-    }
-    async handleAstTransformChain(args) {
-        try {
-            const name = this.requireString(args.name, 'name').trim();
-            const description = typeof args.description === 'string' && args.description.trim().length > 0
-                ? args.description.trim()
-                : undefined;
-            const transforms = this.parseTransforms(args.transforms);
-            if (name.length === 0) {
-                throw new Error('name cannot be empty');
-            }
-            this.chains.set(name, {
-                name,
-                transforms,
-                description,
-                createdAt: Date.now(),
-            });
-            return this.toTextResponse({
-                name,
-                transforms,
-                created: true,
-            });
-        }
-        catch (error) {
-            return this.fail('ast_transform_chain', error);
-        }
-    }
-    async handleAstTransformApply(args) {
-        try {
-            const chainName = typeof args.chainName === 'string' ? args.chainName.trim() : '';
-            const inlineCode = typeof args.code === 'string' ? args.code : '';
-            const scriptId = typeof args.scriptId === 'string' ? args.scriptId.trim() : '';
-            const sourceCode = inlineCode.length > 0
-                ? inlineCode
-                : scriptId.length > 0
-                    ? await this.resolveScriptSource(scriptId)
-                    : '';
-            if (sourceCode.length === 0) {
-                throw new Error('Either code or scriptId must be provided');
-            }
-            const transforms = this.resolveTransformsForApply(chainName, args.transforms);
-            const result = this.applyTransforms(sourceCode, transforms);
-            return this.toTextResponse({
-                transformed: result.transformed,
-                stats: {
-                    originalSize: sourceCode.length,
-                    transformedSize: result.transformed.length,
-                    transformsApplied: result.appliedTransforms,
-                },
-            });
-        }
-        catch (error) {
-            return this.fail('ast_transform_apply', error);
-        }
-    }
-}