apcore-js 0.5.0 → 0.7.0

package/tests/registry/test-scanner.test.ts

@@ -1,257 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import {
-  mkdtempSync,
-  mkdirSync,
-  writeFileSync,
-  rmSync,
-  chmodSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join, sep } from 'node:path';
-import { scanExtensions, scanMultiRoot } from '../../src/registry/scanner.js';
-import { ConfigNotFoundError, ConfigError } from '../../src/errors.js';
-
-let tempDir: string;
-
-beforeEach(() => {
-  tempDir = mkdtempSync(join(tmpdir(), 'scanner-test-'));
-});
-
-afterEach(() => {
-  rmSync(tempDir, { recursive: true, force: true });
-});
-
-function touch(relativePath: string, content = ''): string {
-  const full = join(tempDir, relativePath);
-  const dir = full.substring(0, full.lastIndexOf(sep));
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(full, content);
-  return full;
-}
-
-describe('scanExtensions', () => {
-  it('discovers .ts and .js files and returns correct DiscoveredModule shape', () => {
-    touch('alpha.ts');
-    touch('beta.js');
-
-    const results = scanExtensions(tempDir);
-    expect(results).toHaveLength(2);
-    const ids = results.map((r) => r.canonicalId).sort();
-    expect(ids).toEqual(['alpha', 'beta']);
-
-    for (const mod of results) {
-      expect(mod.filePath).toBeTruthy();
-      expect(mod.canonicalId).toBeTruthy();
-      expect(mod.metaPath).toBeNull();
-      expect(mod.namespace).toBeNull();
-    }
-  });
-
-  it('builds dot-notation canonicalId from nested paths', () => {
-    touch('sub/module.ts');
-    touch('deep/nested/handler.js');
-
-    const results = scanExtensions(tempDir);
-    const ids = results.map((r) => r.canonicalId).sort();
-    expect(ids).toEqual(['deep.nested.handler', 'sub.module']);
-  });
-
-  it('skips .d.ts declaration files', () => {
-    touch('real.ts');
-    touch('types.d.ts');
-
-    const results = scanExtensions(tempDir);
-    expect(results).toHaveLength(1);
-    expect(results[0].canonicalId).toBe('real');
-  });
-
-  it('skips .test.ts, .test.js, .spec.ts, and .spec.js files', () => {
-    touch('handler.ts');
-    touch('handler.test.ts');
-    touch('handler.test.js');
-    touch('handler.spec.ts');
-    touch('handler.spec.js');
-
-    const results = scanExtensions(tempDir);
-    expect(results).toHaveLength(1);
-    expect(results[0].canonicalId).toBe('handler');
-  });
-
-  it('skips dot-prefixed and underscore-prefixed entries', () => {
-    touch('.hidden/secret.ts');
-    touch('_private/internal.ts');
-    touch('.env.ts');
-    touch('_helper.ts');
-    touch('visible.ts');
-
-    const results = scanExtensions(tempDir);
-    expect(results).toHaveLength(1);
-    expect(results[0].canonicalId).toBe('visible');
-  });
-
-  it('skips node_modules and __pycache__ directories', () => {
-    touch('node_modules/pkg/index.ts');
-    touch('__pycache__/cached.ts');
-    touch('real.ts');
-
-    const results = scanExtensions(tempDir);
-    expect(results).toHaveLength(1);
-    expect(results[0].canonicalId).toBe('real');
-  });
-
-  it('ignores non-.ts/.js files', () => {
-    touch('readme.md');
-    touch('config.yaml');
-    touch('data.json');
-    touch('valid.ts');
-
-    const results = scanExtensions(tempDir);
-    expect(results).toHaveLength(1);
-    expect(results[0].canonicalId).toBe('valid');
-  });
-
-  it('detects companion _meta.yaml files', () => {
-    touch('handler.ts');
-    touch('handler_meta.yaml', 'description: a handler');
-
-    const results = scanExtensions(tempDir);
-    expect(results).toHaveLength(1);
-    expect(results[0].metaPath).toBe(join(tempDir, 'handler_meta.yaml'));
-  });
-
-  it('sets metaPath to null when no companion _meta.yaml exists', () => {
-    touch('handler.ts');
-    touch('handler_meta.json', '{}');
-
-    const results = scanExtensions(tempDir);
-    expect(results).toHaveLength(1);
-    expect(results[0].metaPath).toBeNull();
-  });
-
-  it('respects maxDepth parameter', () => {
-    touch('level1.ts');
-    touch('a/level2.ts');
-    touch('a/b/level3.ts');
-
-    const resultsDepth1 = scanExtensions(tempDir, 1);
-    expect(resultsDepth1.map((r) => r.canonicalId).sort()).toEqual(['level1']);
-
-    const resultsDepth2 = scanExtensions(tempDir, 2);
-    expect(resultsDepth2.map((r) => r.canonicalId).sort()).toEqual(['a.level2', 'level1']);
-
-    const resultsAll = scanExtensions(tempDir, 8);
-    expect(resultsAll.map((r) => r.canonicalId).sort()).toEqual(['a.b.level3', 'a.level2', 'level1']);
-  });
-
-  it('throws ConfigNotFoundError for non-existent root directory', () => {
-    const bogus = join(tempDir, 'does-not-exist');
-    expect(() => scanExtensions(bogus)).toThrow(ConfigNotFoundError);
-  });
-
-  it('deduplicates by canonicalId (first file wins)', () => {
-    touch('handler.ts');
-    touch('handler.js');
-
-    const results = scanExtensions(tempDir);
-    expect(results).toHaveLength(1);
-    expect(results[0].canonicalId).toBe('handler');
-  });
-
-  it('handles deeply nested structures correctly', () => {
-    touch('a/b/c/d/e/module.ts');
-
-    const results = scanExtensions(tempDir);
-    expect(results).toHaveLength(1);
-    expect(results[0].canonicalId).toBe('a.b.c.d.e.module');
-  });
-
-  it('returns empty array for an empty directory', () => {
-    const results = scanExtensions(tempDir);
-    expect(results).toEqual([]);
-  });
-
-  it('filePath is an absolute path to the discovered file', () => {
-    touch('mod.ts');
-
-    const results = scanExtensions(tempDir);
-    expect(results).toHaveLength(1);
-    expect(results[0].filePath).toBe(join(tempDir, 'mod.ts'));
-  });
-});
-
-describe('scanMultiRoot', () => {
-  it('prefixes canonicalId with namespace', () => {
-    const rootA = join(tempDir, 'rootA');
-    mkdirSync(rootA);
-    writeFileSync(join(rootA, 'handler.ts'), '');
-
-    const results = scanMultiRoot([{ root: rootA, namespace: 'ns1' }]);
-    expect(results).toHaveLength(1);
-    expect(results[0].canonicalId).toBe('ns1.handler');
-    expect(results[0].namespace).toBe('ns1');
-  });
-
-  it('auto-uses directory basename as namespace when not specified', () => {
-    const rootDir = join(tempDir, 'myextensions');
-    mkdirSync(rootDir);
-    writeFileSync(join(rootDir, 'action.ts'), '');
-
-    const results = scanMultiRoot([{ root: rootDir }]);
-    expect(results).toHaveLength(1);
-    expect(results[0].canonicalId).toBe('myextensions.action');
-    expect(results[0].namespace).toBe('myextensions');
-  });
-
-  it('throws ConfigError for duplicate namespaces', () => {
-    const rootA = join(tempDir, 'a');
-    const rootB = join(tempDir, 'b');
-    mkdirSync(rootA);
-    mkdirSync(rootB);
-
-    expect(() =>
-      scanMultiRoot([
-        { root: rootA, namespace: 'dup' },
-        { root: rootB, namespace: 'dup' },
-      ]),
-    ).toThrow(ConfigError);
-  });
-
-  it('merges results from multiple roots', () => {
-    const rootA = join(tempDir, 'rootA');
-    const rootB = join(tempDir, 'rootB');
-    mkdirSync(rootA);
-    mkdirSync(rootB);
-    writeFileSync(join(rootA, 'foo.ts'), '');
-    writeFileSync(join(rootB, 'bar.ts'), '');
-
-    const results = scanMultiRoot([
-      { root: rootA, namespace: 'a' },
-      { root: rootB, namespace: 'b' },
-    ]);
-    expect(results).toHaveLength(2);
-    const ids = results.map((r) => r.canonicalId).sort();
-    expect(ids).toEqual(['a.foo', 'b.bar']);
-  });
-
-  it('propagates ConfigNotFoundError for non-existent root', () => {
-    const bogus = join(tempDir, 'nonexistent');
-    expect(() => scanMultiRoot([{ root: bogus, namespace: 'ns' }])).toThrow(ConfigNotFoundError);
-  });
-
-  it('handles empty roots array', () => {
-    const results = scanMultiRoot([]);
-    expect(results).toEqual([]);
-  });
-
-  it('preserves metaPath through multi-root scan', () => {
-    const rootDir = join(tempDir, 'ext');
-    mkdirSync(rootDir);
-    writeFileSync(join(rootDir, 'mod.ts'), '');
-    writeFileSync(join(rootDir, 'mod_meta.yaml'), 'description: test');
-
-    const results = scanMultiRoot([{ root: rootDir, namespace: 'pkg' }]);
-    expect(results).toHaveLength(1);
-    expect(results[0].metaPath).toBe(join(rootDir, 'mod_meta.yaml'));
-    expect(results[0].canonicalId).toBe('pkg.mod');
-  });
-});

package/tests/registry/test-schema-export.test.ts

@@ -1,355 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Type } from '@sinclair/typebox';
-import { Registry } from '../../src/registry/registry.js';
-import { FunctionModule } from '../../src/decorator.js';
-import { InvalidInputError, ModuleNotFoundError } from '../../src/errors.js';
-import {
-  getSchema,
-  exportSchema,
-  getAllSchemas,
-  exportAllSchemas,
-} from '../../src/registry/schema-export.js';
-
-const inputSchema = Type.Object({
-  prompt: Type.String({ description: 'The input prompt' }),
-  temperature: Type.Optional(Type.Number({ description: 'Sampling temperature' })),
-});
-
-const outputSchema = Type.Object({
-  text: Type.String(),
-});
-
-function createModule(
-  id: string,
-  overrides?: Partial<ConstructorParameters<typeof FunctionModule>[0]>,
-): FunctionModule {
-  return new FunctionModule({
-    execute: () => ({ text: 'hello' }),
-    moduleId: id,
-    inputSchema,
-    outputSchema,
-    description: 'A test module. It does many things.\nSecond paragraph.',
-    tags: ['ai', 'test'],
-    version: '2.0.0',
-    annotations: {
-      readonly: true,
-      destructive: false,
-      idempotent: true,
-      requiresApproval: false,
-      openWorld: false,
-      streaming: false,
-    },
-    examples: [
-      {
-        title: 'Basic example',
-        inputs: { prompt: 'hi' },
-        output: { text: 'hello' },
-        description: 'Simple greeting',
-      },
-    ],
-    ...overrides,
-  });
-}
-
-function makeRegistry(...modules: Array<[string, FunctionModule]>): Registry {
-  const registry = new Registry();
-  for (const [id, mod] of modules) {
-    registry.register(id, mod);
-  }
-  return registry;
-}
-
-describe('getSchema', () => {
-  it('returns null for unregistered module', () => {
-    const registry = new Registry();
-    expect(getSchema(registry, 'no.such.module')).toBeNull();
-  });
-
-  it('returns schema record with all expected fields', () => {
-    const mod = createModule('test.gen');
-    const registry = makeRegistry(['test.gen', mod]);
-
-    const schema = getSchema(registry, 'test.gen');
-    expect(schema).not.toBeNull();
-    expect(schema!['module_id']).toBe('test.gen');
-    expect(schema!['description']).toBe('A test module. It does many things.\nSecond paragraph.');
-    expect(schema!['version']).toBe('2.0.0');
-    expect(schema!['tags']).toEqual(['ai', 'test']);
-    expect(schema!['input_schema']).toBeDefined();
-    expect(schema!['output_schema']).toBeDefined();
-    expect(schema!['examples']).toHaveLength(1);
-  });
-
-  it('copies tags array to prevent mutation', () => {
-    const mod = createModule('test.tags');
-    const registry = makeRegistry(['test.tags', mod]);
-
-    const schema = getSchema(registry, 'test.tags');
-    const tags = schema!['tags'] as string[];
-    tags.push('injected');
-
-    expect(mod.tags).toEqual(['ai', 'test']);
-  });
-
-  it('returns empty array for tags when module has null tags', () => {
-    const mod = createModule('test.notags', { tags: null });
-    const registry = makeRegistry(['test.notags', mod]);
-    const schema = getSchema(registry, 'test.notags');
-    expect(schema!['tags']).toEqual([]);
-  });
-
-  it('returns null annotations when module has no annotations', () => {
-    const mod = createModule('test.noanno', { annotations: null });
-    const registry = makeRegistry(['test.noanno', mod]);
-    const schema = getSchema(registry, 'test.noanno');
-    expect(schema!['annotations']).toBeNull();
-  });
-});
-
-describe('exportSchema', () => {
-  it('returns JSON string by default', () => {
-    const mod = createModule('test.json');
-    const registry = makeRegistry(['test.json', mod]);
-
-    const result = exportSchema(registry, 'test.json');
-    const parsed = JSON.parse(result);
-    expect(parsed['module_id']).toBe('test.json');
-    expect(parsed['version']).toBe('2.0.0');
-  });
-
-  it('returns YAML string when format is yaml', () => {
-    const mod = createModule('test.yaml');
-    const registry = makeRegistry(['test.yaml', mod]);
-
-    const result = exportSchema(registry, 'test.yaml', 'yaml');
-    expect(result).toContain('module_id:');
-    expect(result).toContain('test.yaml');
-  });
-
-  it('throws ModuleNotFoundError for unregistered module', () => {
-    const registry = new Registry();
-    expect(() => exportSchema(registry, 'no.such.module')).toThrow(ModuleNotFoundError);
-  });
-
-  it('applies strict mode to input and output schemas', () => {
-    const mod = createModule('test.strict');
-    const registry = makeRegistry(['test.strict', mod]);
-
-    const result = exportSchema(registry, 'test.strict', 'json', true);
-    const parsed = JSON.parse(result);
-    expect((parsed['input_schema'] as Record<string, unknown>)['additionalProperties']).toBe(false);
-    expect((parsed['output_schema'] as Record<string, unknown>)['additionalProperties']).toBe(false);
-  });
-
-  it('compact mode truncates description at first sentence boundary', () => {
-    const mod = createModule('test.compact');
-    const registry = makeRegistry(['test.compact', mod]);
-
-    const result = exportSchema(registry, 'test.compact', 'json', false, true);
-    const parsed = JSON.parse(result);
-    expect(parsed['description']).toBe('A test module.');
-  });
-
-  it('compact mode removes examples and documentation', () => {
-    const mod = createModule('test.compact.ex', { documentation: 'Full docs' });
-    const registry = makeRegistry(['test.compact.ex', mod]);
-
-    const result = exportSchema(registry, 'test.compact.ex', 'json', false, true);
-    const parsed = JSON.parse(result);
-    expect(parsed['examples']).toBeUndefined();
-    expect(parsed['documentation']).toBeUndefined();
-  });
-
-  it('strict takes precedence over compact when both are true', () => {
-    const mod = createModule('test.both');
-    const registry = makeRegistry(['test.both', mod]);
-
-    const result = exportSchema(registry, 'test.both', 'json', true, true);
-    const parsed = JSON.parse(result);
-    expect((parsed['input_schema'] as Record<string, unknown>)['additionalProperties']).toBe(false);
-    expect(parsed['description']).toBe('A test module. It does many things.\nSecond paragraph.');
-    expect(parsed['examples']).toBeDefined();
-  });
-});
-
-describe('getAllSchemas', () => {
-  it('returns empty object for empty registry', () => {
-    const registry = new Registry();
-    expect(getAllSchemas(registry)).toEqual({});
-  });
-
-  it('returns all module schemas keyed by module id', () => {
-    const modA = createModule('alpha');
-    const modB = createModule('beta', { version: '3.0.0' });
-    const registry = makeRegistry(['alpha', modA], ['beta', modB]);
-
-    const result = getAllSchemas(registry);
-    expect(Object.keys(result).sort()).toEqual(['alpha', 'beta']);
-    expect(result['alpha']['module_id']).toBe('alpha');
-    expect(result['beta']['version']).toBe('3.0.0');
-  });
-});
-
-describe('exportAllSchemas', () => {
-  it('serializes all schemas to JSON', () => {
-    const modA = createModule('a.mod');
-    const modB = createModule('b.mod');
-    const registry = makeRegistry(['a.mod', modA], ['b.mod', modB]);
-
-    const result = exportAllSchemas(registry);
-    const parsed = JSON.parse(result);
-    expect(Object.keys(parsed).sort()).toEqual(['a.mod', 'b.mod']);
-  });
-
-  it('supports YAML format', () => {
-    const mod = createModule('yaml.mod');
-    const registry = makeRegistry(['yaml.mod', mod]);
-
-    const result = exportAllSchemas(registry, 'yaml');
-    expect(result).toContain('yaml.mod');
-  });
-
-  it('applies strict mode to all schemas', () => {
-    const modA = createModule('strict.a');
-    const registry = makeRegistry(['strict.a', modA]);
-
-    const result = exportAllSchemas(registry, 'json', true);
-    const parsed = JSON.parse(result);
-    expect((parsed['strict.a']['input_schema'] as Record<string, unknown>)['additionalProperties']).toBe(false);
-  });
-
-  it('applies compact mode to all schemas', () => {
-    const mod = createModule('compact.all');
-    const registry = makeRegistry(['compact.all', mod]);
-
-    const result = exportAllSchemas(registry, 'json', false, true);
-    const parsed = JSON.parse(result);
-    expect(parsed['compact.all']['description']).toBe('A test module.');
-    expect(parsed['compact.all']['examples']).toBeUndefined();
-  });
-
-  it('returns empty JSON object for empty registry', () => {
-    const registry = new Registry();
-    expect(JSON.parse(exportAllSchemas(registry))).toEqual({});
-  });
-});
-
-describe('exportSchema with profile', () => {
-  it('exports with mcp profile and returns valid JSON with MCP shape', () => {
-    const mod = createModule('mcp.mod');
-    const registry = makeRegistry(['mcp.mod', mod]);
-
-    const result = exportSchema(registry, 'mcp.mod', 'json', false, false, 'mcp');
-    const parsed = JSON.parse(result);
-    expect(parsed['name']).toBeDefined();
-    expect(parsed['description']).toBeDefined();
-    expect(parsed['inputSchema']).toBeDefined();
-    expect(parsed['annotations']).toBeDefined();
-    expect(parsed['annotations']['readOnlyHint']).toBe(true);
-    expect(parsed['annotations']['destructiveHint']).toBe(false);
-  });
-
-  it('exports with openai profile and returns function tool shape', () => {
-    const mod = createModule('openai.mod');
-    const registry = makeRegistry(['openai.mod', mod]);
-
-    const result = exportSchema(registry, 'openai.mod', 'json', false, false, 'openai');
-    const parsed = JSON.parse(result);
-    expect(parsed['type']).toBe('function');
-    expect(parsed['function']).toBeDefined();
-    expect(parsed['function']['name']).toBe('openai_mod');
-    expect(parsed['function']['description']).toBeDefined();
-    expect(parsed['function']['parameters']).toBeDefined();
-    expect(parsed['function']['strict']).toBe(true);
-  });
-
-  it('exports with anthropic profile and returns tool shape with input_examples', () => {
-    const mod = createModule('anthro.mod');
-    const registry = makeRegistry(['anthro.mod', mod]);
-
-    const result = exportSchema(registry, 'anthro.mod', 'json', false, false, 'anthropic');
-    const parsed = JSON.parse(result);
-    expect(parsed['name']).toBe('anthro_mod');
-    expect(parsed['description']).toBeDefined();
-    expect(parsed['input_schema']).toBeDefined();
-    expect(parsed['input_examples']).toBeDefined();
-    expect((parsed['input_examples'] as unknown[]).length).toBe(1);
-  });
-
-  it('exports with generic profile and returns module_id and schema fields', () => {
-    const mod = createModule('generic.mod');
-    const registry = makeRegistry(['generic.mod', mod]);
-
-    const result = exportSchema(registry, 'generic.mod', 'json', false, false, 'generic');
-    const parsed = JSON.parse(result);
-    expect(parsed['module_id']).toBe('generic.mod');
-    expect(parsed['description']).toBeDefined();
-    expect(parsed['input_schema']).toBeDefined();
-    expect(parsed['output_schema']).toBeDefined();
-    expect(parsed['definitions']).toBeDefined();
-  });
-
-  it('exports with profile using yaml format', () => {
-    const mod = createModule('mcp.yaml');
-    const registry = makeRegistry(['mcp.yaml', mod]);
-
-    const result = exportSchema(registry, 'mcp.yaml', 'yaml', false, false, 'mcp');
-    expect(result).toContain('name:');
-    expect(result).toContain('inputSchema:');
-  });
-
-  it('throws InvalidInputError for an unrecognized profile name', () => {
-    const mod = createModule('bad.profile');
-    const registry = makeRegistry(['bad.profile', mod]);
-
-    expect(() =>
-      exportSchema(registry, 'bad.profile', 'json', false, false, 'not_a_real_profile'),
-    ).toThrow(InvalidInputError);
-  });
-
-  it('includes the invalid profile name in the error message', () => {
-    const mod = createModule('err.profile');
-    const registry = makeRegistry(['err.profile', mod]);
-
-    expect(() =>
-      exportSchema(registry, 'err.profile', 'json', false, false, 'bogus'),
-    ).toThrowError(/bogus/);
-  });
-});
-
-describe('truncateDescription edge cases', () => {
-  it('returns the full string when there is no dot-space or newline', () => {
-    const mod = createModule('no.boundary', {
-      description: 'A simple description with no sentence boundary',
-    });
-    const registry = makeRegistry(['no.boundary', mod]);
-
-    const result = exportSchema(registry, 'no.boundary', 'json', false, true);
-    const parsed = JSON.parse(result);
-    expect(parsed['description']).toBe('A simple description with no sentence boundary');
-  });
-
-  it('truncates at the earlier boundary when both dot-space and newline are present', () => {
-    // newline comes before dot-space: "Line one\nSecond sentence. More text."
-    const mod = createModule('newline.first', {
-      description: 'Line one\nSecond sentence. More text.',
-    });
-    const registry = makeRegistry(['newline.first', mod]);
-
-    const result = exportSchema(registry, 'newline.first', 'json', false, true);
-    const parsed = JSON.parse(result);
-    expect(parsed['description']).toBe('Line one');
-  });
-
-  it('truncates at dot-space when it comes before a newline', () => {
-    // dot-space before newline: "First sentence. Second line\nThird."
-    const mod = createModule('dotspace.first', {
-      description: 'First sentence. Second line\nThird.',
-    });
-    const registry = makeRegistry(['dotspace.first', mod]);
-
-    const result = exportSchema(registry, 'dotspace.first', 'json', false, true);
-    const parsed = JSON.parse(result);
-    expect(parsed['description']).toBe('First sentence.');
-  });
-});

package/tests/registry/test-validation.test.ts

@@ -1,75 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Type } from '@sinclair/typebox';
-import { validateModule } from '../../src/registry/validation.js';
-
-describe('validateModule', () => {
-  it('valid module returns no errors', () => {
-    const mod = {
-      inputSchema: Type.Object({}),
-      outputSchema: Type.Object({}),
-      description: 'A test module',
-      execute: () => ({}),
-    };
-    expect(validateModule(mod)).toEqual([]);
-  });
-
-  it('missing inputSchema reports error', () => {
-    const mod = {
-      outputSchema: Type.Object({}),
-      description: 'test',
-      execute: () => ({}),
-    };
-    const errors = validateModule(mod);
-    expect(errors.length).toBeGreaterThan(0);
-    expect(errors.some(e => e.includes('inputSchema'))).toBe(true);
-  });
-
-  it('missing outputSchema reports error', () => {
-    const mod = {
-      inputSchema: Type.Object({}),
-      description: 'test',
-      execute: () => ({}),
-    };
-    const errors = validateModule(mod);
-    expect(errors.length).toBeGreaterThan(0);
-    expect(errors.some(e => e.includes('outputSchema'))).toBe(true);
-  });
-
-  it('missing description reports error', () => {
-    const mod = {
-      inputSchema: Type.Object({}),
-      outputSchema: Type.Object({}),
-      execute: () => ({}),
-    };
-    const errors = validateModule(mod);
-    expect(errors.length).toBeGreaterThan(0);
-    expect(errors.some(e => e.includes('description'))).toBe(true);
-  });
-
-  it('missing execute reports error', () => {
-    const mod = {
-      inputSchema: Type.Object({}),
-      outputSchema: Type.Object({}),
-      description: 'test',
-    };
-    const errors = validateModule(mod);
-    expect(errors.length).toBeGreaterThan(0);
-    expect(errors.some(e => e.includes('execute'))).toBe(true);
-  });
-
-  it('completely empty object reports multiple errors', () => {
-    const errors = validateModule({});
-    expect(errors.length).toBe(4);
-  });
-
-  it('non-function execute reports error', () => {
-    const mod = {
-      inputSchema: Type.Object({}),
-      outputSchema: Type.Object({}),
-      description: 'test',
-      execute: 'not-a-function',
-    };
-    const errors = validateModule(mod);
-    expect(errors.some(e => e.includes('execute'))).toBe(true);
-  });
-});