@lantos1618/better-ui 0.2.2 → 0.3.1

package/lib/aui/__tests__/aui-integration.test.ts

@@ -1,309 +0,0 @@
-import aui from '../index';
-import { z } from 'zod';
-import { ServerExecutor } from '../server-executor';
-
-describe('AUI Integration Tests', () => {
-  beforeEach(() => {
-    aui.clear();
-  });
-  
-  describe('Simple Tool Creation', () => {
-    it('should create a simple tool with just input and execute', async () => {
-      const tool = aui
-        .tool('simple')
-        .input(z.object({ value: z.number() }))
-        .execute(async ({ input }) => ({ result: input.value * 2 }));
-      
-      const result = await tool.run({ value: 5 });
-      expect(result).toEqual({ result: 10 });
-    });
-    
-    it('should work without input schema', async () => {
-      const tool = aui
-        .tool('noSchema')
-        .execute(async ({ input }) => ({ received: input }));
-      
-      const result = await tool.run({ anything: 'works' });
-      expect(result).toEqual({ received: { anything: 'works' } });
-    });
-  });
-  
-  describe('Client and Server Execution', () => {
-    it('should use server execution by default', async () => {
-      const serverFn = jest.fn(async ({ input }) => ({ server: true, value: input }));
-      const clientFn = jest.fn(async ({ input }) => ({ server: false, client: true, value: input }));
-      
-      const tool = aui
-        .tool('dual')
-        .execute(serverFn)
-        .clientExecute(clientFn);
-      
-      // Default context is server
-      const result = await tool.run({ test: 1 });
-      
-      expect(serverFn).toHaveBeenCalled();
-      expect(clientFn).not.toHaveBeenCalled();
-      expect(result).toEqual({ server: true, value: { test: 1 } });
-    });
-    
-    it('should use client execution when isServer is false', async () => {
-      const serverFn = jest.fn(async ({ input }) => ({ server: true }));
-      const clientFn = jest.fn(async ({ input }) => ({ server: false, client: true }));
-      
-      const tool = aui
-        .tool('dual')
-        .execute(serverFn)
-        .clientExecute(clientFn);
-      
-      const result = await tool.run({}, { isServer: false, cache: new Map(), fetch });
-      
-      expect(serverFn).not.toHaveBeenCalled();
-      expect(clientFn).toHaveBeenCalled();
-      expect(result).toEqual({ server: false, client: true });
-    });
-  });
-  
-  describe('Context and Caching', () => {
-    it('should pass context to execution handlers', async () => {
-      const tool = aui
-        .tool('contextTest')
-        .execute(async ({ input, ctx }) => ({
-          hasCache: ctx?.cache instanceof Map,
-          hasFetch: typeof ctx?.fetch === 'function',
-          isServer: ctx?.isServer
-        }));
-      
-      const result = await tool.run({});
-      expect(result.hasCache).toBe(true);
-      expect(result.hasFetch).toBe(true);
-      expect(result.isServer).toBe(true);
-    });
-    
-    it('should support caching in client execution', async () => {
-      const cache = new Map();
-      let callCount = 0;
-      
-      const tool = aui
-        .tool('cached')
-        .input(z.object({ key: z.string() }))
-        .clientExecute(async ({ input, ctx }) => {
-          if (ctx.cache.has(input.key)) {
-            return ctx.cache.get(input.key);
-          }
-          callCount++;
-          const result = { value: callCount, key: input.key };
-          ctx.cache.set(input.key, result);
-          return result;
-        });
-      
-      const ctx = { cache, fetch, isServer: false };
-      
-      const result1 = await tool.run({ key: 'test' }, ctx);
-      const result2 = await tool.run({ key: 'test' }, ctx);
-      const result3 = await tool.run({ key: 'other' }, ctx);
-      
-      expect(result1).toEqual({ value: 1, key: 'test' });
-      expect(result2).toEqual({ value: 1, key: 'test' }); // Cached
-      expect(result3).toEqual({ value: 2, key: 'other' });
-      expect(callCount).toBe(2);
-    });
-  });
-  
-  describe('Middleware', () => {
-    it('should execute middleware in order', async () => {
-      const order: string[] = [];
-      
-      const tool = aui
-        .tool('middleware')
-        .execute(async ({ input }) => {
-          order.push('execute');
-          return { result: input };
-        })
-        .middleware(async ({ input, next }) => {
-          order.push('middleware1-before');
-          const result = await next();
-          order.push('middleware1-after');
-          return result;
-        })
-        .middleware(async ({ input, next }) => {
-          order.push('middleware2-before');
-          const result = await next();
-          order.push('middleware2-after');
-          return result;
-        });
-      
-      await tool.run({ test: 1 });
-      
-      expect(order).toEqual([
-        'middleware1-before',
-        'middleware2-before',
-        'execute',
-        'middleware2-after',
-        'middleware1-after'
-      ]);
-    });
-    
-    it('should allow middleware to modify results', async () => {
-      const tool = aui
-        .tool('transform')
-        .execute(async ({ input }) => ({ value: input.value }))
-        .middleware(async ({ input, next }) => {
-          const result = await next();
-          return { ...result, modified: true };
-        });
-      
-      const result = await tool.run({ value: 10 });
-      expect(result).toEqual({ value: 10, modified: true });
-    });
-  });
-  
-  describe('Tool Registry', () => {
-    it('should register and retrieve tools', () => {
-      const tool1 = aui.tool('tool1');
-      const tool2 = aui.tool('tool2');
-      
-      expect(aui.get('tool1')).toBe(tool1);
-      expect(aui.get('tool2')).toBe(tool2);
-      expect(aui.get('nonexistent')).toBeUndefined();
-    });
-    
-    it('should list all tools', () => {
-      aui.tool('a');
-      aui.tool('b');
-      aui.tool('c');
-      
-      const tools = aui.getTools();
-      expect(tools).toHaveLength(3);
-      expect(aui.getToolNames()).toEqual(['a', 'b', 'c']);
-    });
-    
-    it('should support tags and filtering', () => {
-      aui.tool('weather').tag('api', 'external');
-      aui.tool('database').tag('backend', 'internal');
-      aui.tool('ui').tag('frontend', 'internal');
-      
-      expect(aui.findByTag('internal')).toHaveLength(2);
-      expect(aui.findByTag('api')).toHaveLength(1);
-      expect(aui.findByTags('backend', 'internal')).toHaveLength(1);
-    });
-  });
-  
-  describe('Server Executor', () => {
-    it('should execute tools on server with security checks', async () => {
-      aui.tool('allowed')
-        .execute(async () => ({ success: true }));
-      
-      aui.tool('blocked')
-        .execute(async () => ({ success: false }));
-      
-      const executor = new ServerExecutor({
-        allowedTools: ['allowed'],
-        blockedTools: ['blocked']
-      });
-      
-      const result = await executor.execute('allowed', {});
-      expect(result).toEqual({ success: true });
-      
-      await expect(executor.execute('blocked', {}))
-        .rejects.toThrow('Tool "blocked" is blocked');
-    });
-    
-    it('should handle batch executions', async () => {
-      aui.tool('add')
-        .input(z.object({ a: z.number(), b: z.number() }))
-        .execute(async ({ input }) => input.a + input.b);
-      
-      aui.tool('multiply')
-        .input(z.object({ a: z.number(), b: z.number() }))
-        .execute(async ({ input }) => input.a * input.b);
-      
-      const executor = new ServerExecutor();
-      const results = await executor.executeBatch([
-        { tool: 'add', input: { a: 2, b: 3 } },
-        { tool: 'multiply', input: { a: 4, b: 5 } },
-        { tool: 'nonexistent', input: {} }
-      ]);
-      
-      expect(results[0]).toEqual({ tool: 'add', result: 5 });
-      expect(results[1]).toEqual({ tool: 'multiply', result: 20 });
-      expect(results[2].tool).toBe('nonexistent');
-      expect(results[2].error).toBeDefined();
-    });
-    
-    it('should validate input without execution', async () => {
-      aui.tool('validated')
-        .input(z.object({ 
-          name: z.string().min(3),
-          age: z.number().positive()
-        }))
-        .execute(async ({ input }) => input);
-      
-      const executor = new ServerExecutor();
-      
-      expect(await executor.validate('validated', { name: 'John', age: 25 }))
-        .toBe(true);
-      
-      expect(await executor.validate('validated', { name: 'Jo', age: 25 }))
-        .toBe(false);
-      
-      expect(await executor.validate('validated', { name: 'John', age: -5 }))
-        .toBe(false);
-    });
-  });
-  
-  describe('Error Handling', () => {
-    it('should handle validation errors', async () => {
-      const tool = aui
-        .tool('strict')
-        .input(z.object({ required: z.string() }))
-        .execute(async ({ input }) => input);
-      
-      await expect(tool.run({ wrong: 'field' } as any))
-        .rejects.toThrow();
-    });
-    
-    it('should handle execution errors', async () => {
-      const tool = aui
-        .tool('error')
-        .execute(async () => {
-          throw new Error('Execution failed');
-        });
-      
-      await expect(tool.run({}))
-        .rejects.toThrow('Execution failed');
-    });
-    
-    it('should handle missing execute handler', async () => {
-      const tool = aui.tool('incomplete');
-      
-      await expect(tool.run({}))
-        .rejects.toThrow('Tool incomplete has no execute handler');
-    });
-  });
-  
-  describe('Tool Metadata', () => {
-    it('should export tool metadata as JSON', () => {
-      const tool = aui
-        .tool('metadata')
-        .describe('A test tool')
-        .tag('test', 'example')
-        .input(z.object({ test: z.string() }))
-        .execute(async ({ input }) => input)
-        .clientExecute(async ({ input }) => input)
-        .middleware(async ({ next }) => next());
-      
-      const json = tool.toJSON();
-      
-      expect(json).toEqual({
-        name: 'metadata',
-        description: 'A test tool',
-        tags: ['test', 'example'],
-        hasInput: true,
-        hasExecute: true,
-        hasClientExecute: true,
-        hasRender: false,
-        hasMiddleware: true
-      });
-    });
-  });
-});

package/lib/aui/__tests__/aui-simple.test.ts

@@ -1,116 +0,0 @@
-import aui from '../index';
-import { z } from 'zod';
-
-describe('AUI Simple API', () => {
-  it('creates a simple tool with just 2 methods', () => {
-    const simpleTool = aui
-      .tool('weather')
-      .input(z.object({ city: z.string() }))
-      .execute(async ({ input }) => ({ temp: 72, city: input.city }));
-    
-    expect(simpleTool.name).toBe('weather');
-    expect(simpleTool.schema).toBeDefined();
-  });
-
-  it('executes a simple tool', async () => {
-    const simpleTool = aui
-      .tool('weather')
-      .input(z.object({ city: z.string() }))
-      .execute(async ({ input }) => ({ temp: 72, city: input.city }));
-    
-    const result = await simpleTool.run({ city: 'NYC' });
-    expect(result).toEqual({ temp: 72, city: 'NYC' });
-  });
-
-  it('creates a complex tool with client execution', () => {
-    const complexTool = aui
-      .tool('search')
-      .input(z.object({ query: z.string() }))
-      .execute(async ({ input }) => [`Result for ${input.query}`])
-      .clientExecute(async ({ input, ctx }) => {
-        const cached = ctx.cache.get(input.query);
-        return cached || [`Cached result for ${input.query}`];
-      });
-    
-    expect(complexTool.name).toBe('search');
-    const config = complexTool.getConfig();
-    expect(config.clientHandler).toBeDefined();
-  });
-
-  it('supports middleware', async () => {
-    let middlewareCalled = false;
-    
-    const tool = aui
-      .tool('test')
-      .middleware(async ({ input, next }) => {
-        middlewareCalled = true;
-        return next();
-      })
-      .execute(async () => 'done');
-    
-    await tool.run({});
-    expect(middlewareCalled).toBe(true);
-  });
-
-  it('validates input with zod schema', async () => {
-    const tool = aui
-      .tool('validated')
-      .input(z.object({ 
-        email: z.string().email() 
-      }))
-      .execute(async ({ input }) => input);
-    
-    await expect(tool.run({ email: 'invalid' })).rejects.toThrow();
-    
-    const result = await tool.run({ email: 'test@example.com' });
-    expect(result.email).toBe('test@example.com');
-  });
-
-  it('uses client handler when not on server', async () => {
-    const tool = aui
-      .tool('hybrid')
-      .execute(async () => 'server result')
-      .clientExecute(async () => 'client result');
-    
-    const serverResult = await tool.run({}, { 
-      isServer: true,
-      cache: new Map(),
-      fetch: globalThis.fetch
-    });
-    expect(serverResult).toBe('server result');
-    
-    const clientResult = await tool.run({}, { 
-      isServer: false,
-      cache: new Map(),
-      fetch: globalThis.fetch
-    });
-    expect(clientResult).toBe('client result');
-  });
-
-  it('supports tags and description', () => {
-    const tool = aui
-      .tool('tagged')
-      .tag('user', 'mutation')
-      .describe('A tagged tool')
-      .execute(async () => null);
-    
-    expect(tool.tags).toContain('user');
-    expect(tool.tags).toContain('mutation');
-    expect(tool.description).toBe('A tagged tool');
-  });
-
-  it('finds tools by tags', () => {
-    aui.clear(); // Clear any existing tools
-    
-    aui.tool('tool1').tag('api').execute(async () => null);
-    aui.tool('tool2').tag('api', 'user').execute(async () => null);
-    aui.tool('tool3').tag('user').execute(async () => null);
-    
-    const apiTools = aui.findByTag('api');
-    expect(apiTools).toHaveLength(2);
-    
-    const userApiTools = aui.findByTags('api', 'user');
-    expect(userApiTools).toHaveLength(1);
-    expect(userApiTools[0].name).toBe('tool2');
-  });
-});

package/lib/aui/__tests__/aui.test.ts

@@ -1,269 +0,0 @@
-import aui, { AUI, AUITool } from '../index';
-import { z } from 'zod';
-
-describe('AUI System', () => {
-  let testAUI: AUI;
-  
-  beforeEach(() => {
-    testAUI = new AUI();
-  });
-  
-  describe('Tool Creation', () => {
-    it('should create a simple tool with execute and render', () => {
-      const tool = testAUI
-        .tool('test')
-        .input(z.object({ value: z.number() }))
-        .execute(async ({ input }) => ({ result: input.value * 2 }));
-      
-      expect(tool.name).toBe('test');
-      expect(tool).toBeInstanceOf(AUITool);
-    });
-    
-    it('should chain methods fluently', () => {
-      const tool = testAUI
-        .tool('chain-test')
-        .input(z.object({ text: z.string() }))
-        .execute(async ({ input }) => ({ message: input.text }))
-        .describe('A test tool')
-        .tag('test', 'example');
-      
-      expect(tool.name).toBe('chain-test');
-      expect(tool.description).toBe('A test tool');
-      expect(tool.tags).toContain('test');
-      expect(tool.tags).toContain('example');
-    });
-    
-    it('should support clientExecute for client-side optimization', () => {
-      const tool = testAUI
-        .tool('client-tool')
-        .input(z.object({ id: z.string() }))
-        .execute(async ({ input }) => ({ id: input.id, source: 'server' }))
-        .clientExecute(async ({ input, ctx }) => {
-          const cached = ctx.cache.get(input.id);
-          return cached || { id: input.id, source: 'client' };
-        });
-      
-      expect(tool.name).toBe('client-tool');
-    });
-  });
-  
-  describe('Tool Execution', () => {
-    it('should execute a tool with valid input', async () => {
-      const tool = testAUI
-        .tool('calc')
-        .input(z.object({ a: z.number(), b: z.number() }))
-        .execute(async ({ input }) => ({ sum: input.a + input.b }));
-      
-      const result = await tool.run({ a: 5, b: 3 });
-      expect(result).toEqual({ sum: 8 });
-    });
-    
-    it('should validate input with Zod schema', async () => {
-      const tool = testAUI
-        .tool('strict')
-        .input(z.object({ 
-          email: z.string().email(),
-          age: z.number().min(0).max(120)
-        }))
-        .execute(async ({ input }) => ({ valid: true }));
-      
-      await expect(
-        tool.run({ email: 'invalid', age: 25 })
-      ).rejects.toThrow();
-      
-      const result = await tool.run({ email: 'test@example.com', age: 25 });
-      expect(result).toEqual({ valid: true });
-    });
-    
-    it('should use clientExecute when not on server', async () => {
-      const tool = testAUI
-        .tool('hybrid')
-        .input(z.object({ key: z.string() }))
-        .execute(async ({ input }) => ({ value: 'server', key: input.key }))
-        .clientExecute(async ({ input }) => ({ value: 'client', key: input.key }));
-      
-      const clientCtx = { 
-        cache: new Map(), 
-        fetch: jest.fn(),
-        isServer: false 
-      };
-      
-      const result = await tool.run({ key: 'test' }, clientCtx);
-      expect(result).toEqual({ value: 'client', key: 'test' });
-    });
-    
-    it('should apply middleware in order', async () => {
-      const order: number[] = [];
-      
-      const tool = testAUI
-        .tool('middleware-test')
-        .input(z.object({ value: z.number() }))
-        .middleware(async ({ input, next }) => {
-          order.push(1);
-          const result = await next();
-          order.push(3);
-          return result;
-        })
-        .middleware(async ({ input, next }) => {
-          order.push(2);
-          return next();
-        })
-        .execute(async ({ input }) => {
-          return { value: input.value * 2 };
-        });
-      
-      const result = await tool.run({ value: 5 });
-      expect(result).toEqual({ value: 10 });
-      expect(order).toEqual([1, 2, 3]);
-    });
-  });
-  
-  describe('Tool Registry', () => {
-    it('should register and retrieve tools', () => {
-      const tool1 = testAUI.tool('tool1');
-      const tool2 = testAUI.tool('tool2');
-      
-      expect(testAUI.get('tool1')).toBe(tool1);
-      expect(testAUI.get('tool2')).toBe(tool2);
-      expect(testAUI.has('tool1')).toBe(true);
-      expect(testAUI.has('nonexistent')).toBe(false);
-    });
-    
-    it('should list all tools', () => {
-      testAUI.tool('a').tag('type1');
-      testAUI.tool('b').tag('type2');
-      testAUI.tool('c').tag('type1', 'type2');
-      
-      const tools = testAUI.list();
-      expect(tools).toHaveLength(3);
-      expect(testAUI.getToolNames()).toEqual(['a', 'b', 'c']);
-    });
-    
-    it('should find tools by tags', () => {
-      testAUI.tool('auth').tag('security', 'user');
-      testAUI.tool('db').tag('data', 'storage');
-      testAUI.tool('api').tag('network', 'data');
-      
-      const dataTools = testAUI.findByTag('data');
-      expect(dataTools).toHaveLength(2);
-      
-      const securityTools = testAUI.findByTag('security');
-      expect(securityTools).toHaveLength(1);
-      expect(securityTools[0].name).toBe('auth');
-    });
-    
-    it('should clear and remove tools', () => {
-      testAUI.tool('temp1');
-      testAUI.tool('temp2');
-      
-      expect(testAUI.has('temp1')).toBe(true);
-      testAUI.remove('temp1');
-      expect(testAUI.has('temp1')).toBe(false);
-      
-      testAUI.clear();
-      expect(testAUI.list()).toHaveLength(0);
-    });
-  });
-  
-  describe('Context Management', () => {
-    it('should create default context', () => {
-      const ctx = testAUI.createContext();
-      
-      expect(ctx.cache).toBeInstanceOf(Map);
-      expect(ctx.fetch).toBeDefined();
-      expect(ctx.isServer).toBe(typeof window === 'undefined');
-    });
-    
-    it('should merge context additions', () => {
-      const ctx = testAUI.createContext({
-        user: { id: '123', name: 'Test' },
-        session: { token: 'abc' }
-      });
-      
-      expect(ctx.user).toEqual({ id: '123', name: 'Test' });
-      expect(ctx.session).toEqual({ token: 'abc' });
-      expect(ctx.cache).toBeInstanceOf(Map);
-    });
-    
-    it('should cache results in context', async () => {
-      let callCount = 0;
-      
-      const tool = testAUI
-        .tool('cacheable')
-        .input(z.object({ id: z.string() }))
-        .clientExecute(async ({ input, ctx }) => {
-          const cached = ctx.cache.get(input.id);
-          if (cached) return cached;
-          
-          callCount++;
-          const result = { id: input.id, data: 'fetched' };
-          ctx.cache.set(input.id, result);
-          return result;
-        });
-      
-      const ctx = testAUI.createContext();
-      ctx.isServer = false; // Force client execution
-      
-      const result1 = await tool.run({ id: 'test' }, ctx);
-      const result2 = await tool.run({ id: 'test' }, ctx);
-      
-      expect(callCount).toBe(1);
-      expect(result1).toEqual(result2);
-    });
-  });
-  
-  describe('Error Handling', () => {
-    it('should throw error when tool not found', async () => {
-      await expect(
-        testAUI.execute('nonexistent', {})
-      ).rejects.toThrow('Tool "nonexistent" not found');
-    });
-    
-    it('should throw error when execute handler missing', async () => {
-      const tool = testAUI
-        .tool('incomplete')
-        .input(z.object({ value: z.number() }));
-      
-      await expect(
-        tool.run({ value: 5 })
-      ).rejects.toThrow('Tool incomplete has no execute handler');
-    });
-    
-    it('should handle errors in execute handler', async () => {
-      const tool = testAUI
-        .tool('error-tool')
-        .execute(async () => {
-          throw new Error('Execution failed');
-        });
-      
-      await expect(tool.run({})).rejects.toThrow('Execution failed');
-    });
-  });
-  
-  describe('Tool Serialization', () => {
-    it('should serialize tool to JSON', () => {
-      const tool = testAUI
-        .tool('serializable')
-        .input(z.object({ test: z.string() }))
-        .execute(async () => ({ result: 'ok' }))
-        .clientExecute(async () => ({ result: 'client' }))
-        .describe('A serializable tool')
-        .tag('test', 'json');
-      
-      tool.render(() => null as any);
-      
-      const json = tool.toJSON();
-      
-      expect(json).toEqual({
-        name: 'serializable',
-        description: 'A serializable tool',
-        tags: ['test', 'json'],
-        hasInput: true,
-        hasExecute: true,
-        hasClientExecute: true,
-        hasRender: true,
-        hasMiddleware: false
-      });
-    });
-  });
-});