@lantos1618/better-ui 0.2.2 → 0.3.1

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

@@ -1,376 +0,0 @@
-import aui from '../index';
-import { z } from 'zod';
-
-describe('AUI Comprehensive Tests', () => {
-  beforeEach(() => {
-    aui.clear();
-  });
-
-  describe('Core AUI Functionality', () => {
-    it('should create a simple tool with execute and render', async () => {
-      const tool = aui
-        .tool('test-tool')
-        .input(z.object({ value: z.number() }))
-        .execute(async ({ input }) => ({ result: input.value * 2 }));
-
-      expect(tool.name).toBe('test-tool');
-      
-      const result = await tool.run({ value: 5 });
-      expect(result).toEqual({ result: 10 });
-    });
-
-    it('should handle client execution when not on server', async () => {
-      const clientFn = jest.fn(async ({ input }) => ({ server: false, client: true, value: input.value }));
-      const serverFn = jest.fn(async ({ input }) => ({ server: true, value: input.value }));
-
-      const tool = aui
-        .tool('dual-tool')
-        .input(z.object({ value: z.string() }))
-        .execute(serverFn)
-        .clientExecute(clientFn);
-
-      // Simulate client environment
-      const result = await tool.run(
-        { value: 'test' },
-        { 
-          isServer: false, 
-          cache: new Map(), 
-          fetch: global.fetch 
-        }
-      );
-
-      expect(result).toEqual({ server: false, client: true, value: 'test' });
-      expect(clientFn).toHaveBeenCalled();
-      expect(serverFn).not.toHaveBeenCalled();
-    });
-
-    it('should use server execution when on server', async () => {
-      const clientFn = jest.fn(async ({ input }) => ({ server: false, client: true }));
-      const serverFn = jest.fn(async ({ input }) => ({ server: true }));
-
-      const tool = aui
-        .tool('server-tool')
-        .execute(serverFn)
-        .clientExecute(clientFn);
-
-      const result = await tool.run(
-        {},
-        { 
-          isServer: true, 
-          cache: new Map(), 
-          fetch: global.fetch 
-        }
-      );
-
-      expect(result).toEqual({ server: true });
-      expect(serverFn).toHaveBeenCalled();
-      expect(clientFn).not.toHaveBeenCalled();
-    });
-
-    it('should validate input with Zod schema', async () => {
-      const tool = aui
-        .tool('validated-tool')
-        .input(z.object({ 
-          name: z.string().min(3),
-          age: z.number().positive()
-        }))
-        .execute(async ({ input }) => input);
-
-      await expect(tool.run({ name: 'ab', age: 25 }))
-        .rejects.toThrow();
-
-      await expect(tool.run({ name: 'Alice', age: -5 }))
-        .rejects.toThrow();
-
-      const result = await tool.run({ name: 'Alice', age: 25 });
-      expect(result).toEqual({ name: 'Alice', age: 25 });
-    });
-
-    it('should support middleware', async () => {
-      const middleware1 = jest.fn(async ({ input, next }) => {
-        const result = await next();
-        return { ...result, middleware1: true };
-      });
-
-      const middleware2 = jest.fn(async ({ input, next }) => {
-        const result = await next();
-        return { ...result, middleware2: true };
-      });
-
-      const tool = aui
-        .tool('middleware-tool')
-        .execute(async () => ({ base: true }))
-        .middleware(middleware1)
-        .middleware(middleware2);
-
-      const result = await tool.run({});
-      
-      expect(result).toEqual({
-        base: true,
-        middleware1: true,
-        middleware2: true
-      });
-      expect(middleware1).toHaveBeenCalled();
-      expect(middleware2).toHaveBeenCalled();
-    });
-
-    it('should support tags and descriptions', () => {
-      const tool = aui
-        .tool('tagged-tool')
-        .describe('A tool with tags')
-        .tag('ai', 'control', 'frontend');
-
-      expect(tool.description).toBe('A tool with tags');
-      expect(tool.tags).toEqual(['ai', 'control', 'frontend']);
-    });
-  });
-
-  describe('AUI Instance Management', () => {
-    it('should store and retrieve tools', () => {
-      const tool1 = aui.tool('tool1');
-      const tool2 = aui.tool('tool2');
-
-      expect(aui.has('tool1')).toBe(true);
-      expect(aui.has('tool2')).toBe(true);
-      expect(aui.has('tool3')).toBe(false);
-
-      expect(aui.get('tool1')).toBe(tool1);
-      expect(aui.get('tool2')).toBe(tool2);
-      expect(aui.get('tool3')).toBeUndefined();
-    });
-
-    it('should list all tools', () => {
-      aui.tool('a').tag('type1');
-      aui.tool('b').tag('type2');
-      aui.tool('c').tag('type1', 'type2');
-
-      const tools = aui.list();
-      expect(tools).toHaveLength(3);
-      expect(tools.map(t => t.name)).toEqual(['a', 'b', 'c']);
-    });
-
-    it('should find tools by tags', () => {
-      aui.tool('frontend').tag('ui', 'client');
-      aui.tool('backend').tag('api', 'server');
-      aui.tool('fullstack').tag('ui', 'api');
-
-      const uiTools = aui.findByTag('ui');
-      expect(uiTools).toHaveLength(2);
-      expect(uiTools.map(t => t.name)).toContain('frontend');
-      expect(uiTools.map(t => t.name)).toContain('fullstack');
-
-      const apiTools = aui.findByTags('ui', 'api');
-      expect(apiTools).toHaveLength(1);
-      expect(apiTools[0].name).toBe('fullstack');
-    });
-
-    it('should execute tools by name', async () => {
-      aui
-        .tool('calculator')
-        .input(z.object({ a: z.number(), b: z.number() }))
-        .execute(async ({ input }) => ({ sum: input.a + input.b }));
-
-      const result = await aui.execute('calculator', { a: 3, b: 4 });
-      expect(result).toEqual({ sum: 7 });
-
-      await expect(aui.execute('nonexistent', {}))
-        .rejects.toThrow('Tool "nonexistent" not found');
-    });
-
-    it('should remove tools', () => {
-      aui.tool('temp');
-      expect(aui.has('temp')).toBe(true);
-      
-      const removed = aui.remove('temp');
-      expect(removed).toBe(true);
-      expect(aui.has('temp')).toBe(false);
-      
-      const removedAgain = aui.remove('temp');
-      expect(removedAgain).toBe(false);
-    });
-
-    it('should clear all tools', () => {
-      aui.tool('t1');
-      aui.tool('t2');
-      aui.tool('t3');
-      
-      expect(aui.list()).toHaveLength(3);
-      
-      aui.clear();
-      expect(aui.list()).toHaveLength(0);
-    });
-  });
-
-  describe('Context Management', () => {
-    it('should create default context', () => {
-      const ctx = aui.createContext();
-      
-      expect(ctx.cache).toBeInstanceOf(Map);
-      expect(ctx.fetch).toBeDefined();
-      expect(ctx.isServer).toBe(true); // In test environment
-    });
-
-    it('should merge context additions', () => {
-      const ctx = aui.createContext({
-        user: { id: 1, name: 'Test' },
-        session: { token: 'abc123' },
-        env: { API_KEY: 'secret' }
-      });
-      
-      expect(ctx.user).toEqual({ id: 1, name: 'Test' });
-      expect(ctx.session).toEqual({ token: 'abc123' });
-      expect(ctx.env).toEqual({ API_KEY: 'secret' });
-      expect(ctx.cache).toBeInstanceOf(Map);
-    });
-
-    it('should use context cache in client execution', async () => {
-      const fetchMock = jest.fn(async () => ({ data: 'fresh' }));
-      
-      const tool = aui
-        .tool('cached-tool')
-        .input(z.object({ key: z.string() }))
-        .clientExecute(async ({ input, ctx }) => {
-          const cached = ctx.cache.get(input.key);
-          if (cached) return cached;
-          
-          const result = await fetchMock();
-          ctx.cache.set(input.key, result);
-          return result;
-        });
-
-      const ctx = {
-        cache: new Map(),
-        fetch: global.fetch,
-        isServer: false
-      };
-
-      // First call - should fetch
-      const result1 = await tool.run({ key: 'test' }, ctx);
-      expect(result1).toEqual({ data: 'fresh' });
-      expect(fetchMock).toHaveBeenCalledTimes(1);
-
-      // Second call - should use cache
-      const result2 = await tool.run({ key: 'test' }, ctx);
-      expect(result2).toEqual({ data: 'fresh' });
-      expect(fetchMock).toHaveBeenCalledTimes(1); // Still 1, not called again
-    });
-  });
-
-  describe('Tool Configuration', () => {
-    it('should return tool configuration', () => {
-      const tool = aui
-        .tool('config-tool')
-        .input(z.object({ value: z.string() }))
-        .execute(async ({ input }) => input)
-        .describe('A configurable tool')
-        .tag('test', 'config');
-
-      const config = tool.getConfig();
-      
-      expect(config.name).toBe('config-tool');
-      expect(config.description).toBe('A configurable tool');
-      expect(config.tags).toEqual(['test', 'config']);
-      expect(config.inputSchema).toBeDefined();
-      expect(config.executeHandler).toBeDefined();
-    });
-
-    it('should serialize tool to JSON', () => {
-      const tool = aui
-        .tool('json-tool')
-        .input(z.object({ id: z.number() }))
-        .execute(async () => ({}))
-        .clientExecute(async () => ({}))
-        .middleware(async ({ next }) => next())
-        .describe('JSON serializable tool')
-        .tag('json');
-
-      const json = tool.toJSON();
-      
-      expect(json).toEqual({
-        name: 'json-tool',
-        description: 'JSON serializable tool',
-        tags: ['json'],
-        hasInput: true,
-        hasExecute: true,
-        hasClientExecute: true,
-        hasRender: false,
-        hasMiddleware: true
-      });
-    });
-  });
-
-  describe('Complex Tool Scenarios', () => {
-    it('should handle async operations correctly', async () => {
-      const delays = [100, 50, 150];
-      const results: number[] = [];
-
-      const tool = aui
-        .tool('async-tool')
-        .input(z.object({ delay: z.number(), value: z.number() }))
-        .execute(async ({ input }) => {
-          await new Promise(resolve => setTimeout(resolve, input.delay));
-          results.push(input.value);
-          return { processed: input.value };
-        });
-
-      // Execute in parallel
-      const promises = delays.map((delay, i) => 
-        tool.run({ delay, value: i })
-      );
-
-      const responses = await Promise.all(promises);
-      
-      // Results should be in order of completion (50ms, 100ms, 150ms)
-      expect(results).toEqual([1, 0, 2]);
-      expect(responses).toEqual([
-        { processed: 0 },
-        { processed: 1 },
-        { processed: 2 }
-      ]);
-    });
-
-    it('should handle errors gracefully', async () => {
-      const tool = aui
-        .tool('error-tool')
-        .input(z.object({ shouldFail: z.boolean() }))
-        .execute(async ({ input }) => {
-          if (input.shouldFail) {
-            throw new Error('Intentional failure');
-          }
-          return { success: true };
-        });
-
-      const success = await tool.run({ shouldFail: false });
-      expect(success).toEqual({ success: true });
-
-      await expect(tool.run({ shouldFail: true }))
-        .rejects.toThrow('Intentional failure');
-    });
-
-    it('should chain multiple tools together', async () => {
-      const preprocessor = aui
-        .tool('preprocessor')
-        .input(z.object({ text: z.string() }))
-        .execute(async ({ input }) => ({ 
-          processed: input.text.toUpperCase() 
-        }));
-
-      const analyzer = aui
-        .tool('analyzer')
-        .input(z.object({ processed: z.string() }))
-        .execute(async ({ input }) => ({ 
-          length: input.processed.length,
-          words: input.processed.split(' ').length 
-        }));
-
-      const input = { text: 'hello world' };
-      const preprocessed = await preprocessor.run(input);
-      const analyzed = await analyzer.run(preprocessed);
-
-      expect(analyzed).toEqual({
-        length: 11,
-        words: 2
-      });
-    });
-  });
-});

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

@@ -1,278 +0,0 @@
-import { describe, it, expect, beforeEach } from '@jest/globals';
-import aui, { AUITool, z } from '../index';
-
-describe('AUI Concise API', () => {
-  beforeEach(() => {
-    aui.clear();
-  });
-
-  describe('Simple Tools', () => {
-    it('should create a simple tool with just input and execute', async () => {
-      const weatherTool = aui
-        .tool('weather')
-        .input(z.object({ city: z.string() }))
-        .execute(async ({ input }) => ({ temp: 72, city: input.city }));
-
-      const result = await weatherTool.run({ city: 'SF' });
-      expect(result).toEqual({ temp: 72, city: 'SF' });
-    });
-
-    it('should work without input schema', async () => {
-      const simpleTool = aui
-        .tool('simple')
-        .execute(async () => ({ success: true }));
-
-      const result = await simpleTool.run({});
-      expect(result).toEqual({ success: true });
-    });
-
-    it('should support render method', () => {
-      const tool = aui
-        .tool('ui')
-        .input(z.object({ text: z.string() }))
-        .execute(async ({ input }) => ({ message: input.text }))
-        .render(({ data }) => ({ type: 'div', props: { children: data.message } } as any));
-
-      expect(tool.renderer).toBeDefined();
-    });
-  });
-
-  describe('Complex Tools with Client Execution', () => {
-    it('should use client execution when available and not on server', async () => {
-      const searchTool = aui
-        .tool('search')
-        .input(z.object({ query: z.string() }))
-        .execute(async ({ input }) => ({ server: true, query: input.query }))
-        .clientExecute(async ({ input }) => ({ server: true, query: input.query }));
-
-      const clientContext = { 
-        cache: new Map(), 
-        fetch: global.fetch,
-        isServer: false 
-      };
-
-      const result = await searchTool.run({ query: 'test' }, clientContext);
-      expect(result).toEqual({ server: true, query: 'test' });
-    });
-
-    it('should use server execution when on server', async () => {
-      const searchTool = aui
-        .tool('search')
-        .input(z.object({ query: z.string() }))
-        .execute(async ({ input }) => ({ server: true, query: input.query }))
-        .clientExecute(async ({ input }) => ({ server: false, query: input.query }));
-
-      const serverContext = { 
-        cache: new Map(), 
-        fetch: global.fetch,
-        isServer: true 
-      };
-
-      const result = await searchTool.run({ query: 'test' }, serverContext);
-      expect(result).toEqual({ server: true, query: 'test' });
-    });
-
-    it('should support caching in client execution', async () => {
-      const cache = new Map();
-      let fetchCalls = 0;
-
-      const cachedTool = aui
-        .tool('cached')
-        .input(z.object({ key: z.string() }))
-        .clientExecute(async ({ input, ctx }) => {
-          const cached = ctx.cache.get(input.key);
-          if (cached) return cached;
-          
-          fetchCalls++;
-          const data = { value: `fetched-${input.key}`, calls: fetchCalls };
-          ctx.cache.set(input.key, data);
-          return data;
-        });
-
-      const context = { cache, fetch: global.fetch, isServer: false };
-
-      const result1 = await cachedTool.run({ key: 'test' }, context);
-      const result2 = await cachedTool.run({ key: 'test' }, context);
-
-      expect(result1).toEqual({ value: 'fetched-test', calls: 1 });
-      expect(result2).toEqual({ value: 'fetched-test', calls: 1 });
-      expect(fetchCalls).toBe(1);
-    });
-  });
-
-  describe('AI Control Tools', () => {
-    it('should create DOM control tool', async () => {
-      const domTool = aui
-        .tool('dom')
-        .input(z.object({
-          action: z.enum(['click', 'type', 'scroll']),
-          selector: z.string(),
-          value: z.string().optional()
-        }))
-        .clientExecute(async ({ input }) => {
-          return { success: true, action: input.action };
-        });
-
-      const result = await domTool.run(
-        { action: 'click', selector: '#button' },
-        { cache: new Map(), fetch: global.fetch, isServer: false }
-      );
-
-      expect(result).toEqual({ success: true, action: 'click' });
-    });
-
-    it('should create database control tool', async () => {
-      const dbTool = aui
-        .tool('database')
-        .input(z.object({
-          operation: z.enum(['find', 'create', 'update', 'delete']),
-          collection: z.string(),
-          data: z.any().optional()
-        }))
-        .execute(async ({ input }) => {
-          return { 
-            operation: input.operation, 
-            collection: input.collection,
-            result: 'mock-data' 
-          };
-        });
-
-      const result = await dbTool.run({
-        operation: 'find',
-        collection: 'users'
-      });
-
-      expect(result).toEqual({
-        operation: 'find',
-        collection: 'users',
-        result: 'mock-data'
-      });
-    });
-  });
-
-  describe('Tool Middleware', () => {
-    it('should support middleware', async () => {
-      const events: string[] = [];
-
-      const toolWithMiddleware = aui
-        .tool('middleware-test')
-        .input(z.object({ value: z.number() }))
-        .middleware(async ({ input, next }) => {
-          events.push('middleware-1-before');
-          input.value = input.value * 2;
-          const result = await next();
-          events.push('middleware-1-after');
-          return result;
-        })
-        .middleware(async ({ input, next }) => {
-          events.push('middleware-2-before');
-          input.value = input.value + 1;
-          const result = await next();
-          events.push('middleware-2-after');
-          return result;
-        })
-        .execute(async ({ input }) => {
-          events.push('execute');
-          return { finalValue: input.value };
-        });
-
-      const result = await toolWithMiddleware.run({ value: 5 });
-
-      expect(result).toEqual({ finalValue: 11 }); // (5 * 2) + 1
-      expect(events).toEqual([
-        'middleware-1-before',
-        'middleware-2-before',
-        'execute',
-        'middleware-2-after',
-        'middleware-1-after'
-      ]);
-    });
-  });
-
-  describe('Tool Registry', () => {
-    it('should register and retrieve tools', () => {
-      const tool1 = aui.tool('tool1').execute(async () => ({ id: 1 }));
-      const tool2 = aui.tool('tool2').execute(async () => ({ id: 2 }));
-
-      expect(aui.has('tool1')).toBe(true);
-      expect(aui.has('tool2')).toBe(true);
-      expect(aui.getToolNames()).toContain('tool1');
-      expect(aui.getToolNames()).toContain('tool2');
-    });
-
-    it('should execute tools by name', async () => {
-      aui.tool('named')
-        .input(z.object({ value: z.string() }))
-        .execute(async ({ input }) => ({ result: input.value }));
-
-      const result = await aui.execute('named', { value: 'test' });
-      expect(result).toEqual({ result: 'test' });
-    });
-  });
-
-  describe('Type Safety', () => {
-    it('should validate input with Zod schema', async () => {
-      const strictTool = aui
-        .tool('strict')
-        .input(z.object({ 
-          name: z.string().min(1),
-          age: z.number().positive()
-        }))
-        .execute(async ({ input }) => input);
-
-      await expect(
-        strictTool.run({ name: '', age: 25 })
-      ).rejects.toThrow();
-
-      await expect(
-        strictTool.run({ name: 'John', age: -5 })
-      ).rejects.toThrow();
-
-      const validResult = await strictTool.run({ name: 'John', age: 25 });
-      expect(validResult).toEqual({ name: 'John', age: 25 });
-    });
-  });
-
-  describe('Tool Composition', () => {
-    it('should support workflow tools that compose other tools', async () => {
-      aui.tool('add')
-        .input(z.object({ a: z.number(), b: z.number() }))
-        .execute(async ({ input }) => ({ sum: input.a + input.b }));
-
-      aui.tool('multiply')
-        .input(z.object({ a: z.number(), b: z.number() }))
-        .execute(async ({ input }) => ({ product: input.a * input.b }));
-
-      const workflowTool = aui
-        .tool('workflow')
-        .input(z.object({
-          steps: z.array(z.object({
-            tool: z.string(),
-            input: z.any()
-          }))
-        }))
-        .execute(async ({ input }) => {
-          const results = [];
-          for (const step of input.steps) {
-            const result = await aui.execute(step.tool, step.input);
-            results.push(result);
-          }
-          return { results };
-        });
-
-      const result = await workflowTool.run({
-        steps: [
-          { tool: 'add', input: { a: 2, b: 3 } },
-          { tool: 'multiply', input: { a: 4, b: 5 } }
-        ]
-      });
-
-      expect(result).toEqual({
-        results: [
-          { sum: 5 },
-          { product: 20 }
-        ]
-      });
-    });
-  });
-});