@jshookmcp/jshook 0.2.1 → 0.2.2

package/dist/tests/server/domains/transform/transform-ops.test.js

@@ -1,242 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { TransformToolHandlersOps } from '../../../../src/server/domains/transform/handlers.impl.transform-ops.js';
-vi.mock('@utils/WorkerPool', () => ({
-    WorkerPool: class MockWorkerPool {
-        submit = vi.fn();
-        close = vi.fn().mockResolvedValue(undefined);
-    },
-}));
-vi.mock('@src/constants', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        TRANSFORM_WORKER_TIMEOUT_MS: 5000,
-        TRANSFORM_CRYPTO_POOL_MAX_WORKERS: 2,
-        TRANSFORM_CRYPTO_POOL_IDLE_TIMEOUT_MS: 30000,
-        TRANSFORM_CRYPTO_POOL_MAX_OLD_GEN_MB: 64,
-        TRANSFORM_CRYPTO_POOL_MAX_YOUNG_GEN_MB: 32,
-    };
-});
-class TestableOps extends TransformToolHandlersOps {
-    constructor() {
-        super(null);
-    }
-    testTransformConstantFold(code) {
-        return this.transformConstantFold(code);
-    }
-    testTransformStringDecrypt(code) {
-        return this.transformStringDecrypt(code);
-    }
-    testTransformDeadCodeRemove(code) {
-        return this.transformDeadCodeRemove(code);
-    }
-    testTransformControlFlowFlatten(code) {
-        return this.transformControlFlowFlatten(code);
-    }
-    testTransformRenameVars(code) {
-        return this.transformRenameVars(code);
-    }
-    testApplySingleTransform(code, kind) {
-        return this.applySingleTransform(code, kind);
-    }
-    testApplyTransforms(code, kinds) {
-        return this.applyTransforms(code, kinds);
-    }
-    testBuildDiff(a, b) {
-        return this.buildDiff(a, b);
-    }
-    testBuildFallbackDiff(a, b) {
-        return this.buildFallbackDiff(a, b);
-    }
-    testParseTransforms(raw) {
-        return this.parseTransforms(raw);
-    }
-    testParseBoolean(raw, def) {
-        return this.parseBoolean(raw, def);
-    }
-    testRequireString(raw, field) {
-        return this.requireString(raw, field);
-    }
-    testEscapeStringContent(v, q) {
-        return this.escapeStringContent(v, q);
-    }
-    testDecodeEscapedString(v) {
-        return this.decodeEscapedString(v);
-    }
-    testIsValidIdentifier(v) {
-        return this.isValidIdentifier(v);
-    }
-    testParseTestInputs(raw) {
-        return this.parseTestInputs(raw);
-    }
-    getChains() {
-        return this.chains;
-    }
-    testResolveTransformsForApply(chainName, raw) {
-        return this.resolveTransformsForApply(chainName, raw);
-    }
-}
-describe('TransformToolHandlersOps', () => {
-    let ops;
-    beforeEach(() => {
-        ops = new TestableOps();
-    });
-    describe('transformConstantFold', () => {
-        it('folds numeric binary expressions', () => {
-            expect(ops.testTransformConstantFold('1+2')).toBe('3');
-            expect(ops.testTransformConstantFold('10-3')).toBe('7');
-            expect(ops.testTransformConstantFold('4*5')).toBe('20');
-            expect(ops.testTransformConstantFold('10/2')).toBe('5');
-            expect(ops.testTransformConstantFold('10%3')).toBe('1');
-        });
-        it('leaves division/modulo by zero unchanged', () => {
-            expect(ops.testTransformConstantFold('10/0')).toBe('10/0');
-            expect(ops.testTransformConstantFold('10%0')).toBe('10%0');
-        });
-        it('leaves non-finite results unchanged', () => {
-            const big = `1${'0'.repeat(200)}`;
-            const expr = `${big}*${big}`;
-            expect(ops.testTransformConstantFold(expr)).toBe(expr);
-        });
-        it('folds string concatenations and normalizes mixed quotes to single quotes', () => {
-            expect(ops.testTransformConstantFold(`'a'+'b'`)).toBe(`'ab'`);
-            expect(ops.testTransformConstantFold(`'a'+"b"`)).toBe(`'ab'`);
-        });
-        it('folds iteratively across rounds', () => {
-            expect(ops.testTransformConstantFold('1+2+3')).toBe('6');
-        });
-    });
-    describe('transformStringDecrypt', () => {
-        it('decodes hex escapes inside string literals', () => {
-            expect(ops.testTransformStringDecrypt("'\\x48\\x65\\x6c\\x6c\\x6f'")).toBe("'Hello'");
-        });
-        it('decodes unicode escapes inside string literals', () => {
-            expect(ops.testTransformStringDecrypt("'\\u0048\\u0065'")).toBe("'He'");
-        });
-        it('leaves already-plain strings unchanged', () => {
-            expect(ops.testTransformStringDecrypt(`'Hello'`)).toBe(`'Hello'`);
-        });
-    });
-    describe('transformDeadCodeRemove', () => {
-        it('replaces if(false){dead}else{live} with live body', () => {
-            expect(ops.testTransformDeadCodeRemove('if(false){dead}else{live}')).toBe('live');
-        });
-        it('removes if(false){dead} entirely', () => {
-            expect(ops.testTransformDeadCodeRemove('if(false){dead}')).toBe('');
-        });
-        it('removes if(0){dead} entirely', () => {
-            expect(ops.testTransformDeadCodeRemove('if(0){dead}')).toBe('');
-        });
-        it('leaves normal if statements unchanged', () => {
-            const code = 'if(x){dead}else{live}';
-            expect(ops.testTransformDeadCodeRemove(code)).toBe(code);
-        });
-    });
-    describe('transformControlFlowFlatten', () => {
-        it('rebuilds statements from standard switch dispatch pattern', () => {
-            const code = `var order="2|0|1".split("|");var i=0;while(!![]){switch(order[i++]){case "0":console.log("a");continue;case "1":console.log("b");continue;case "2":console.log("c");continue;}break;}`;
-            const expected = `console.log("c");\nconsole.log("a");\nconsole.log("b");`;
-            expect(ops.testTransformControlFlowFlatten(code)).toBe(expected);
-        });
-        it('returns unchanged when no pattern matches', () => {
-            const code = 'var x = 1; x++;';
-            expect(ops.testTransformControlFlowFlatten(code)).toBe(code);
-        });
-    });
-    describe('transformRenameVars', () => {
-        it('renames single-letter vars', () => {
-            const code = 'var a = 1; a + 2';
-            expect(ops.testTransformRenameVars(code)).toBe('var var_1 = 1; var_1 + 2');
-        });
-        it('leaves code unchanged when there are no single-letter var/let/const declarations', () => {
-            const code = 'var alpha = 1; alpha + 2';
-            expect(ops.testTransformRenameVars(code)).toBe(code);
-        });
-        it('does not rename after dots', () => {
-            const code = 'var a = 1; obj.a = a;';
-            const out = ops.testTransformRenameVars(code);
-            expect(out).toContain('obj.a');
-            expect(out).toContain('var var_1');
-        });
-    });
-    describe('applySingleTransform', () => {
-        it('dispatches constant_fold to transformConstantFold', () => {
-            expect(ops.testApplySingleTransform('1+2', 'constant_fold')).toBe('3');
-        });
-        it('dispatches string_decrypt to transformStringDecrypt', () => {
-            expect(ops.testApplySingleTransform("'\\x48\\x69'", 'string_decrypt')).toBe("'Hi'");
-        });
-        it('dispatches dead_code_remove to transformDeadCodeRemove', () => {
-            expect(ops.testApplySingleTransform('if(false){a}', 'dead_code_remove')).toBe('');
-        });
-        it('dispatches control_flow_flatten to transformControlFlowFlatten', () => {
-            const code = `var o="0".split("|");var i=0;while(!![]){switch(o[i++]){case "0":console.log("x");continue;}break;}`;
-            expect(ops.testApplySingleTransform(code, 'control_flow_flatten')).toBe(`console.log("x");`);
-        });
-        it('dispatches rename_vars to transformRenameVars', () => {
-            expect(ops.testApplySingleTransform('let a = 1; a;', 'rename_vars')).toBe('let var_1 = 1; var_1;');
-        });
-        it('returns code unchanged for unknown transform kind', () => {
-            const code = 'const x = 1;';
-            expect(ops.testApplySingleTransform(code, 'unknown')).toBe(code);
-        });
-    });
-    describe('applyTransforms', () => {
-        it('returns only actually-changed transforms in appliedTransforms', () => {
-            const result = ops.testApplyTransforms('const x = 1+2;', ['constant_fold', 'dead_code_remove']);
-            expect(result.transformed).toBe('const x = 3;');
-            expect(result.appliedTransforms).toEqual(['constant_fold']);
-        });
-        it('applies transforms in order', () => {
-            const code = 'if(false){var a=1;a;}else{var b=2;b;}';
-            const result = ops.testApplyTransforms(code, ['dead_code_remove', 'rename_vars']);
-            expect(result.appliedTransforms).toEqual(['dead_code_remove', 'rename_vars']);
-        });
-    });
-    describe('buildDiff', () => {
-        it('returns empty diff when strings are identical', () => {
-            expect(ops.testBuildDiff('a\nb', 'a\nb')).toBe('');
-        });
-        it('emits + and - lines when content differs', () => {
-            const diff = ops.testBuildDiff('a\nb\nc', 'a\nx\nc');
-            expect(diff).toContain('-b');
-            expect(diff).toContain('+x');
-        });
-        it('uses fallback diff for large inputs', () => {
-            const spy = vi.spyOn(ops, 'buildFallbackDiff');
-            const oldText = Array.from({ length: 600 }, (_, i) => `L${i}`).join('\n');
-            const newText = Array.from({ length: 600 }, (_, i) => (i === 300 ? `X${i}` : `L${i}`)).join('\n');
-            const diff = ops.testBuildDiff(oldText, newText);
-            expect(spy).toHaveBeenCalledTimes(1);
-            expect(diff).toContain('-L300');
-            expect(diff).toContain('+X300');
-        });
-    });
-    describe('buildFallbackDiff', () => {
-        it('computes a minimal prefix/suffix diff', () => {
-            const diff = ops.testBuildFallbackDiff(['a', 'b', 'c'], ['a', 'x', 'c']);
-            expect(diff).toBe('-b\n+x');
-        });
-    });
-    describe('resolveTransformsForApply', () => {
-        it('uses parseTransforms when chainName is empty', () => {
-            expect(ops.testResolveTransformsForApply('', ['constant_fold', 'constant_fold'])).toEqual([
-                'constant_fold',
-            ]);
-        });
-        it('returns the chain transforms when chainName exists', () => {
-            ops.getChains().set('fast', {
-                name: 'fast',
-                transforms: ['constant_fold', 'dead_code_remove'],
-                createdAt: Date.now(),
-            });
-            expect(ops.testResolveTransformsForApply('fast', null)).toEqual([
-                'constant_fold',
-                'dead_code_remove',
-            ]);
-        });
-        it('throws when chainName is unknown', () => {
-            expect(() => ops.testResolveTransformsForApply('missing', ['constant_fold'])).toThrow('Transform chain not found: missing');
-        });
-    });
-});

package/dist/tests/server/domains/wasm/definitions.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/server/domains/wasm/definitions.test.js

@@ -1,270 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { wasmTools } from '../../../../src/server/domains/wasm/definitions.js';
-function getTool(name) {
-    const tool = wasmTools.find((candidate) => candidate.name === name);
-    expect(tool).toBeDefined();
-    return tool;
-}
-function getDescription(tool) {
-    return tool.description ?? '';
-}
-function getProperties(tool) {
-    return (tool.inputSchema.properties ?? {});
-}
-function getProperty(tool, key) {
-    const property = getProperties(tool)[key];
-    expect(property).toBeDefined();
-    return property ?? {};
-}
-describe('wasm/definitions', () => {
-    it('exports a non-empty array of tool definitions', () => {
-        expect(Array.isArray(wasmTools)).toBe(true);
-        expect(wasmTools.length).toBeGreaterThan(0);
-    });
-    it('exports exactly 8 tools', () => {
-        expect(wasmTools).toHaveLength(8);
-    });
-    it('contains all expected tool names', () => {
-        const names = wasmTools.map((t) => t.name);
-        expect(names).toContain('wasm_dump');
-        expect(names).toContain('wasm_disassemble');
-        expect(names).toContain('wasm_decompile');
-        expect(names).toContain('wasm_inspect_sections');
-        expect(names).toContain('wasm_offline_run');
-        expect(names).toContain('wasm_optimize');
-        expect(names).toContain('wasm_vmp_trace');
-        expect(names).toContain('wasm_memory_inspect');
-    });
-    it('has unique tool names', () => {
-        const names = wasmTools.map((t) => t.name);
-        expect(new Set(names).size).toBe(names.length);
-    });
-    it('every tool has name, description, and inputSchema', () => {
-        for (const tool of wasmTools) {
-            const description = getDescription(tool);
-            expect(typeof tool.name).toBe('string');
-            expect(tool.name.length).toBeGreaterThan(0);
-            expect(typeof tool.description).toBe('string');
-            expect(description.length).toBeGreaterThan(0);
-            expect(tool.inputSchema).toBeDefined();
-            expect(tool.inputSchema.type).toBe('object');
-        }
-    });
-    it('every tool name starts with "wasm_"', () => {
-        for (const tool of wasmTools) {
-            expect(tool.name.startsWith('wasm_')).toBe(true);
-        }
-    });
-    describe('wasm_dump', () => {
-        const tool = getTool('wasm_dump');
-        it('has optional moduleIndex and outputPath properties', () => {
-            const moduleIndex = getProperty(tool, 'moduleIndex');
-            const outputPath = getProperty(tool, 'outputPath');
-            expect(moduleIndex.type).toBe('number');
-            expect(moduleIndex.default).toBe(0);
-            expect(outputPath.type).toBe('string');
-        });
-        it('has no required fields', () => {
-            expect(tool.inputSchema.required).toBeUndefined();
-        });
-        it('description mentions WASM', () => {
-            expect(getDescription(tool).toLowerCase()).toContain('wasm');
-        });
-    });
-    describe('wasm_disassemble', () => {
-        const tool = getTool('wasm_disassemble');
-        it('requires inputPath', () => {
-            expect(tool.inputSchema.required).toContain('inputPath');
-        });
-        it('has inputPath, outputPath, and foldExprs properties', () => {
-            const inputPath = getProperty(tool, 'inputPath');
-            const outputPath = getProperty(tool, 'outputPath');
-            const foldExprs = getProperty(tool, 'foldExprs');
-            expect(inputPath.type).toBe('string');
-            expect(outputPath.type).toBe('string');
-            expect(foldExprs.type).toBe('boolean');
-            expect(foldExprs.default).toBe(true);
-        });
-        it('description mentions WAT or wasm2wat', () => {
-            expect(getDescription(tool).includes('WAT') || getDescription(tool).includes('wasm2wat')).toBe(true);
-        });
-    });
-    describe('wasm_decompile', () => {
-        const tool = getTool('wasm_decompile');
-        it('requires inputPath', () => {
-            expect(tool.inputSchema.required).toContain('inputPath');
-        });
-        it('has inputPath and outputPath properties', () => {
-            const props = getProperties(tool);
-            expect(props.inputPath).toBeDefined();
-            expect(props.outputPath).toBeDefined();
-        });
-        it('description mentions C-like or wasm-decompile', () => {
-            expect(getDescription(tool).includes('C-like') || getDescription(tool).includes('wasm-decompile')).toBe(true);
-        });
-    });
-    describe('wasm_inspect_sections', () => {
-        const tool = getTool('wasm_inspect_sections');
-        it('requires inputPath', () => {
-            expect(tool.inputSchema.required).toContain('inputPath');
-        });
-        it('has sections enum with expected values', () => {
-            const sections = getProperty(tool, 'sections');
-            expect(sections.enum).toEqual(['headers', 'details', 'disassemble', 'all']);
-            expect(sections.default).toBe('details');
-        });
-    });
-    describe('wasm_offline_run', () => {
-        const tool = getTool('wasm_offline_run');
-        it('requires inputPath and functionName', () => {
-            expect(tool.inputSchema.required).toContain('inputPath');
-            expect(tool.inputSchema.required).toContain('functionName');
-        });
-        it('has args as array of strings', () => {
-            const args = getProperty(tool, 'args');
-            expect(args.type).toBe('array');
-            expect(args.items?.type).toBe('string');
-        });
-        it('has runtime enum with expected values', () => {
-            const runtime = getProperty(tool, 'runtime');
-            expect(runtime.enum).toEqual(['wasmtime', 'wasmer', 'auto']);
-            expect(runtime.default).toBe('auto');
-        });
-        it('has timeoutMs with default 10000', () => {
-            const timeoutMs = getProperty(tool, 'timeoutMs');
-            expect(timeoutMs.type).toBe('number');
-            expect(timeoutMs.default).toBe(10000);
-        });
-        it('description mentions sandbox or security', () => {
-            expect(getDescription(tool).toLowerCase()).toContain('sandbox');
-        });
-    });
-    describe('wasm_optimize', () => {
-        const tool = getTool('wasm_optimize');
-        it('requires inputPath', () => {
-            expect(tool.inputSchema.required).toContain('inputPath');
-        });
-        it('has level enum with optimization levels', () => {
-            const level = getProperty(tool, 'level');
-            expect(level.enum).toEqual(['O1', 'O2', 'O3', 'O4', 'Os', 'Oz']);
-            expect(level.default).toBe('O2');
-        });
-        it('description mentions binaryen or wasm-opt', () => {
-            expect(getDescription(tool).includes('binaryen') || getDescription(tool).includes('wasm-opt')).toBe(true);
-        });
-    });
-    describe('wasm_vmp_trace', () => {
-        const tool = getTool('wasm_vmp_trace');
-        it('has optional maxEvents with default 5000', () => {
-            const maxEvents = getProperty(tool, 'maxEvents');
-            expect(maxEvents.type).toBe('number');
-            expect(maxEvents.default).toBe(5000);
-        });
-        it('has optional filterModule string', () => {
-            const filterModule = getProperty(tool, 'filterModule');
-            expect(filterModule.type).toBe('string');
-        });
-        it('has no required fields', () => {
-            expect(tool.inputSchema.required).toBeUndefined();
-        });
-        it('description mentions VMP', () => {
-            expect(getDescription(tool)).toContain('VMP');
-        });
-    });
-    describe('wasm_memory_inspect', () => {
-        const tool = getTool('wasm_memory_inspect');
-        it('has offset with default 0', () => {
-            const offset = getProperty(tool, 'offset');
-            expect(offset.type).toBe('number');
-            expect(offset.default).toBe(0);
-        });
-        it('has length with default 256', () => {
-            const length = getProperty(tool, 'length');
-            expect(length.type).toBe('number');
-            expect(length.default).toBe(256);
-        });
-        it('has format enum with expected values', () => {
-            const format = getProperty(tool, 'format');
-            expect(format.enum).toEqual(['hex', 'ascii', 'both']);
-            expect(format.default).toBe('both');
-        });
-        it('has optional searchPattern', () => {
-            const searchPattern = getProperty(tool, 'searchPattern');
-            expect(searchPattern.type).toBe('string');
-        });
-        it('has no required fields', () => {
-            expect(tool.inputSchema.required).toBeUndefined();
-        });
-        it('description mentions memory or linear memory', () => {
-            const desc = getDescription(tool).toLowerCase();
-            expect(desc.includes('memory')).toBe(true);
-        });
-    });
-    describe('schema structural consistency', () => {
-        it('all tools with required fields list only properties that exist', () => {
-            for (const tool of wasmTools) {
-                const required = tool.inputSchema.required;
-                if (!required)
-                    continue;
-                const props = Object.keys(tool.inputSchema.properties ?? {});
-                for (const field of required) {
-                    expect(props).toContain(field);
-                }
-            }
-        });
-        it('all property values have a type field', () => {
-            for (const tool of wasmTools) {
-                const props = getProperties(tool);
-                if (!props)
-                    continue;
-                for (const schema of Object.values(props)) {
-                    expect(schema.type).toBeDefined();
-                }
-            }
-        });
-        it('enum properties have at least 2 values', () => {
-            for (const tool of wasmTools) {
-                const props = getProperties(tool);
-                if (!props)
-                    continue;
-                for (const schema of Object.values(props)) {
-                    if (schema.enum) {
-                        expect(schema.enum.length).toBeGreaterThanOrEqual(2);
-                    }
-                }
-            }
-        });
-        it('default values match the declared type', () => {
-            for (const tool of wasmTools) {
-                const props = getProperties(tool);
-                if (!props)
-                    continue;
-                for (const schema of Object.values(props)) {
-                    if (schema.default === undefined)
-                        continue;
-                    if (schema.type === 'number') {
-                        expect(typeof schema.default).toBe('number');
-                    }
-                    else if (schema.type === 'string') {
-                        expect(typeof schema.default).toBe('string');
-                    }
-                    else if (schema.type === 'boolean') {
-                        expect(typeof schema.default).toBe('boolean');
-                    }
-                }
-            }
-        });
-        it('default values for enum properties are included in the enum', () => {
-            for (const tool of wasmTools) {
-                const props = getProperties(tool);
-                if (!props)
-                    continue;
-                for (const schema of Object.values(props)) {
-                    if (schema.enum && schema.default !== undefined) {
-                        expect(schema.enum).toContain(schema.default);
-                    }
-                }
-            }
-        });
-    });
-});

package/dist/tests/server/domains/wasm/exports.test.d.ts

@@ -1 +0,0 @@
-import '../shared/manifest-test-mocks.js';

package/dist/tests/server/domains/wasm/exports.test.js

@@ -1,19 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import '../shared/manifest-test-mocks.js';
-import { assertDomainExportContract } from '../shared/export-contract-helpers.js';
-describe('server/domains/wasm exports', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        vi.resetModules();
-    });
-    it('exposes wasm tool definitions and a matching manifest', async () => {
-        expect.hasAssertions();
-        await assertDomainExportContract({
-            expectedDomain: 'wasm',
-            definitionExportNames: ['wasmTools'],
-            loadDefinitions: () => import('../../../../src/server/domains/wasm/definitions.js'),
-            getToolArrays: (module) => [module.wasmTools],
-            loadManifest: () => import('../../../../src/server/domains/wasm/manifest.js'),
-        });
-    });
-});

package/dist/tests/server/domains/wasm/handlers-additional.test.d.ts

@@ -1 +0,0 @@
-export {};