skyloom 1.4.0

package/tests/tool.test.ts

@@ -0,0 +1,108 @@
+/**
+ * Tests for tool system.
+ */
+import { describe, it, expect, vi } from 'vitest';
+import { ToolRegistry, type ToolDefinition } from '../src/core/tool';
+
+function makeTool(overrides: Partial<ToolDefinition> & { name: string }): ToolDefinition {
+  return {
+    name: overrides.name,
+    description: overrides.description ?? 'Test tool',
+    parameters: overrides.parameters ?? [],
+    handler: overrides.handler ?? vi.fn().mockResolvedValue('ok'),
+    dangerous: overrides.dangerous,
+    cacheable: overrides.cacheable,
+    maxRetries: overrides.maxRetries,
+    retryDelay: overrides.retryDelay,
+    timeout: overrides.timeout,
+  };
+}
+
+describe('ToolRegistry', () => {
+  let registry: ToolRegistry;
+
+  beforeEach(() => {
+    registry = new ToolRegistry();
+  });
+
+  it('register and get tool', () => {
+    const tool = makeTool({ name: 'test_tool' });
+    registry.register(tool);
+    expect(registry.get('test_tool')).toBe(tool);
+    expect(registry.get('nonexistent')).toBeUndefined();
+  });
+
+  it('list returns all tools', () => {
+    registry.register(makeTool({ name: 'a', description: 'A' }));
+    registry.register(makeTool({ name: 'b', description: 'B' }));
+    expect(registry.list()).toHaveLength(2);
+  });
+
+  it('listNames returns all names', () => {
+    registry.register(makeTool({ name: 'alpha', description: 'Alpha' }));
+    registry.register(makeTool({ name: 'beta', description: 'Beta' }));
+    const names = registry.listNames();
+    expect(names).toContain('alpha');
+    expect(names).toContain('beta');
+  });
+
+  it('getTools returns all tools', () => {
+    registry.register(makeTool({ name: 'x', description: 'X' }));
+    expect(registry.getTools()).toHaveLength(1);
+  });
+
+  it('reregister overrides existing', () => {
+    const t1 = makeTool({ name: 't', description: 'v1' });
+    const t2 = makeTool({ name: 't', description: 'v2' });
+    registry.register(t1);
+    registry.register(t2);
+    expect(registry.get('t')?.description).toBe('v2');
+  });
+
+  it('unregister removes tool', () => {
+    registry.register(makeTool({ name: 'temp', description: 'Temp' }));
+    expect(registry.get('temp')).toBeDefined();
+    registry.unregister('temp');
+    expect(registry.get('temp')).toBeUndefined();
+  });
+
+  it('has checks existence', () => {
+    registry.register(makeTool({ name: 'exists' }));
+    expect(registry.has('exists')).toBe(true);
+    expect(registry.has('missing')).toBe(false);
+  });
+
+  it('merge copies tools', () => {
+    const r2 = new ToolRegistry();
+    r2.register(makeTool({ name: 't2', description: 'T2' }));
+    registry.merge(r2);
+    expect(registry.get('t2')).toBeDefined();
+  });
+
+  it('execute returns result from handler', async () => {
+    const handler = vi.fn().mockResolvedValue('hello world');
+    registry.register(makeTool({ name: 'greet', handler }));
+    const result = await registry.execute('greet', { name: 'world' });
+    expect(result.success).toBe(true);
+    expect(result.result).toBe('hello world');
+  });
+
+  it('execute returns error for unknown tool', async () => {
+    const result = await registry.execute('unknown', {});
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('not found');
+  });
+
+  it('execute validates required parameters', async () => {
+    const handler = vi.fn().mockResolvedValue('ok');
+    registry.register(makeTool({
+      name: 'needs_path',
+      parameters: [{ name: 'path', type: 'string', description: 'File path', required: true }],
+      handler,
+    }));
+    const result = await registry.execute('needs_path', {});
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('required');
+    expect(handler).not.toHaveBeenCalled();
+  });
+});

package/tests/tool_router.test.ts

@@ -0,0 +1,71 @@
+/**
+ * Tests for tool subset routing.
+ */
+import { describe, it, expect } from 'vitest';
+import { selectRelevantTools } from '../src/core/tool_router';
+import { ToolRegistry } from '../src/core/tool';
+
+function makeRegistry(toolSpecs: Array<[string, string]>): ToolRegistry {
+  const r = new ToolRegistry();
+  for (const [name, desc] of toolSpecs) {
+    r.register({
+      name,
+      description: desc,
+      parameters: [{ name: 'x', type: 'string', description: 'x' }],
+      handler: async () => 'ok',
+    });
+  }
+  return r;
+}
+
+describe('selectRelevantTools', () => {
+  it('short query returns full set', () => {
+    const r = makeRegistry(Array.from({ length: 20 }, (_, i) => [`tool_${i}`, `desc ${i}`]));
+    const names = r.listNames();
+    const selected = selectRelevantTools(r, names, 'ok', { topK: 5 });
+    expect(new Set(selected)).toEqual(new Set(names));
+  });
+
+  it('small catalog returns full set', () => {
+    const r = makeRegistry([['a', 'alpha'], ['b', 'beta']]);
+    const names = r.listNames();
+    const selected = selectRelevantTools(r, names, 'anything goes here', { topK: 12 });
+    expect(new Set(selected)).toEqual(new Set(names));
+  });
+
+  it('caps at topK for large catalog', () => {
+    const r = makeRegistry(Array.from({ length: 50 }, (_, i) => [`tool_${i}`, `desc ${i}`]));
+    const names = r.listNames();
+    const selected = selectRelevantTools(r, names, 'find weather data', { topK: 10 });
+    expect(selected.length).toBeLessThanOrEqual(10);
+  });
+
+  it('relevant tools score higher', () => {
+    const r = makeRegistry([
+      ['read_file', 'read a file from disk'],
+      ['write_file', 'write content to a file'],
+      ['send_email', 'send an email message'],
+      ['fetch_url', 'fetch a web URL'],
+      ['query_db', 'query the database'],
+    ]);
+    const names = r.listNames();
+    const selected = selectRelevantTools(r, names, 'read this config file', { topK: 3 });
+    expect(selected).toContain('read_file');
+  });
+
+  it('mustInclude always present', () => {
+    const r = makeRegistry(Array.from({ length: 20 }, (_, i) => [`random_${i}`, `unrelated tool ${i}`]));
+    r.register({
+      name: 'critical_tool',
+      description: 'must always be available',
+      parameters: [{ name: 'x', type: 'string', description: 'x' }],
+      handler: async () => 'ok',
+    });
+    const names = r.listNames();
+    const selected = selectRelevantTools(r, names, 'totally unrelated query', {
+      topK: 3,
+      mustInclude: new Set(['critical_tool']),
+    });
+    expect(selected).toContain('critical_tool');
+  });
+});

package/tsconfig.json

@@ -0,0 +1,37 @@
+{
+  "compilerOptions": {
+    "module": "CommonJS",
+    "target": "ES2020",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "strictPropertyInitialization": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "allowSyntheticDefaultImports": true,
+    "moduleResolution": "node",
+    "baseUrl": ".",
+    "paths": {
+      "@skyloom/*": ["src/*"],
+      "@/*": ["src/*"]
+    }
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "tests"]
+}

package/vitest.config.ts

@@ -0,0 +1,17 @@
+import { defineConfig } from 'vitest/config';
+import path from 'path';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['tests/**/*.test.ts'],
+    setupFiles: ['tests/setup.ts'],
+  },
+  resolve: {
+    alias: {
+      '@skyloom': path.resolve(__dirname, 'src'),
+      '@': path.resolve(__dirname, 'src'),
+    },
+  },
+});