@lantos1618/better-ui 0.1.0

package/lib/aui/hooks/useAUIToolEnhanced.ts

@@ -0,0 +1,343 @@
+import { useState, useCallback, useRef, useEffect } from 'react';
+import { AUITool, AUIContext } from '../index';
+
+export interface UseAUIToolOptions<TInput, TOutput> {
+  // Caching
+  cacheKey?: string | ((input: TInput) => string);
+  cacheDuration?: number; // milliseconds
+  
+  // Retry
+  retryCount?: number;
+  retryDelay?: number | ((attempt: number) => number);
+  
+  // Callbacks
+  onSuccess?: (data: TOutput, input: TInput) => void;
+  onError?: (error: Error, input: TInput) => void;
+  onLoadingChange?: (loading: boolean) => void;
+  
+  // Debounce/Throttle
+  debounceMs?: number;
+  throttleMs?: number;
+  
+  // Auto-execute
+  autoExecute?: boolean;
+  autoExecuteInput?: TInput;
+  
+  // Polling
+  pollingInterval?: number;
+  pollingCondition?: (data: TOutput | null) => boolean;
+  
+  // Context
+  context?: Partial<AUIContext>;
+}
+
+export interface UseAUIToolResult<TInput, TOutput> {
+  execute: (input: TInput) => Promise<TOutput>;
+  cancel: () => void;
+  reset: () => void;
+  data: TOutput | null;
+  error: Error | null;
+  loading: boolean;
+  isSuccess: boolean;
+  isError: boolean;
+  isIdle: boolean;
+  executionCount: number;
+  lastExecutedAt: Date | null;
+}
+
+export function useAUIToolEnhanced<TInput = any, TOutput = any>(
+  tool: AUITool<TInput, TOutput>,
+  options: UseAUIToolOptions<TInput, TOutput> = {}
+): UseAUIToolResult<TInput, TOutput> {
+  const [data, setData] = useState<TOutput | null>(null);
+  const [error, setError] = useState<Error | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [executionCount, setExecutionCount] = useState(0);
+  const [lastExecutedAt, setLastExecutedAt] = useState<Date | null>(null);
+  
+  const abortControllerRef = useRef<AbortController | null>(null);
+  const debounceTimerRef = useRef<NodeJS.Timeout | null>(null);
+  const throttleTimerRef = useRef<NodeJS.Timeout | null>(null);
+  const pollingTimerRef = useRef<NodeJS.Timeout | null>(null);
+  const cacheRef = useRef<Map<string, { data: TOutput; expires: number }>>(new Map());
+  
+  // Clear timers on unmount
+  useEffect(() => {
+    return () => {
+      if (debounceTimerRef.current) clearTimeout(debounceTimerRef.current);
+      if (throttleTimerRef.current) clearTimeout(throttleTimerRef.current);
+      if (pollingTimerRef.current) clearInterval(pollingTimerRef.current);
+      if (abortControllerRef.current) abortControllerRef.current.abort();
+    };
+  }, []);
+  
+  // Handle loading state changes
+  useEffect(() => {
+    options.onLoadingChange?.(loading);
+  }, [loading, options]);
+  
+  // Get cache key for input
+  const getCacheKey = useCallback((input: TInput): string => {
+    if (!options.cacheKey) return '';
+    if (typeof options.cacheKey === 'function') {
+      return options.cacheKey(input);
+    }
+    return options.cacheKey;
+  }, [options]);
+  
+  // Check cache
+  const checkCache = useCallback((input: TInput): TOutput | null => {
+    if (!options.cacheKey) return null;
+    
+    const key = getCacheKey(input);
+    const cached = cacheRef.current.get(key);
+    
+    if (cached && cached.expires > Date.now()) {
+      return cached.data;
+    }
+    
+    return null;
+  }, [getCacheKey, options.cacheKey]);
+  
+  // Set cache
+  const setCache = useCallback((input: TInput, data: TOutput) => {
+    if (!options.cacheKey) return;
+    
+    const key = getCacheKey(input);
+    const expires = Date.now() + (options.cacheDuration || 5 * 60 * 1000);
+    cacheRef.current.set(key, { data, expires });
+  }, [getCacheKey, options.cacheKey, options.cacheDuration]);
+  
+  // Execute with retry
+  const executeWithRetry = useCallback(async (
+    input: TInput,
+    attempt: number = 0
+  ): Promise<TOutput> => {
+    try {
+      const context: AUIContext = {
+        cache: new Map(),
+        fetch: globalThis.fetch,
+        isServer: typeof window === 'undefined',
+        ...options.context
+      };
+      
+      const result = await tool.run(input, context);
+      return result;
+    } catch (error) {
+      const maxRetries = options.retryCount || 0;
+      
+      if (attempt < maxRetries) {
+        const delay = typeof options.retryDelay === 'function'
+          ? options.retryDelay(attempt)
+          : options.retryDelay || Math.pow(2, attempt) * 1000;
+        
+        await new Promise(resolve => setTimeout(resolve, delay));
+        return executeWithRetry(input, attempt + 1);
+      }
+      
+      throw error;
+    }
+  }, [tool, options]);
+  
+  // Main execute function
+  const execute = useCallback(async (input: TInput): Promise<TOutput> => {
+    // Check cache first
+    const cached = checkCache(input);
+    if (cached) {
+      setData(cached);
+      setError(null);
+      options.onSuccess?.(cached, input);
+      return cached;
+    }
+    
+    // Cancel previous request
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+    }
+    
+    // Create new abort controller
+    abortControllerRef.current = new AbortController();
+    
+    setLoading(true);
+    setError(null);
+    setExecutionCount(prev => prev + 1);
+    setLastExecutedAt(new Date());
+    
+    try {
+      const result = await executeWithRetry(input);
+      
+      // Check if aborted
+      if (abortControllerRef.current?.signal.aborted) {
+        throw new Error('Request cancelled');
+      }
+      
+      setData(result);
+      setCache(input, result);
+      options.onSuccess?.(result, input);
+      
+      // Start polling if configured
+      if (options.pollingInterval && options.pollingCondition?.(result)) {
+        if (pollingTimerRef.current) clearInterval(pollingTimerRef.current);
+        
+        pollingTimerRef.current = setInterval(() => {
+          execute(input);
+        }, options.pollingInterval);
+      }
+      
+      return result;
+    } catch (err) {
+      const error = err as Error;
+      setError(error);
+      options.onError?.(error, input);
+      throw error;
+    } finally {
+      setLoading(false);
+    }
+  }, [
+    checkCache,
+    executeWithRetry,
+    setCache,
+    options
+  ]);
+  
+  // Debounced execute
+  const debouncedExecute = useCallback((input: TInput): Promise<TOutput> => {
+    return new Promise((resolve, reject) => {
+      if (debounceTimerRef.current) {
+        clearTimeout(debounceTimerRef.current);
+      }
+      
+      debounceTimerRef.current = setTimeout(() => {
+        execute(input).then(resolve).catch(reject);
+      }, options.debounceMs);
+    });
+  }, [execute, options.debounceMs]);
+  
+  // Throttled execute
+  const throttledExecute = useCallback((input: TInput): Promise<TOutput> => {
+    return new Promise((resolve, reject) => {
+      if (throttleTimerRef.current) {
+        reject(new Error('Request throttled'));
+        return;
+      }
+      
+      throttleTimerRef.current = setTimeout(() => {
+        throttleTimerRef.current = null;
+      }, options.throttleMs);
+      
+      execute(input).then(resolve).catch(reject);
+    });
+  }, [execute, options.throttleMs]);
+  
+  // Choose appropriate execute function
+  const finalExecute = options.debounceMs
+    ? debouncedExecute
+    : options.throttleMs
+    ? throttledExecute
+    : execute;
+  
+  // Cancel execution
+  const cancel = useCallback(() => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
+    }
+    if (debounceTimerRef.current) {
+      clearTimeout(debounceTimerRef.current);
+      debounceTimerRef.current = null;
+    }
+    if (pollingTimerRef.current) {
+      clearInterval(pollingTimerRef.current);
+      pollingTimerRef.current = null;
+    }
+    setLoading(false);
+  }, []);
+  
+  // Reset state
+  const reset = useCallback(() => {
+    cancel();
+    setData(null);
+    setError(null);
+    setLoading(false);
+    setExecutionCount(0);
+    setLastExecutedAt(null);
+    cacheRef.current.clear();
+  }, [cancel]);
+  
+  // Auto-execute on mount
+  useEffect(() => {
+    if (options.autoExecute && options.autoExecuteInput) {
+      finalExecute(options.autoExecuteInput);
+    }
+  }, [finalExecute, options.autoExecute, options.autoExecuteInput]);
+  
+  return {
+    execute: finalExecute,
+    cancel,
+    reset,
+    data,
+    error,
+    loading,
+    isSuccess: !loading && !error && data !== null,
+    isError: !loading && error !== null,
+    isIdle: !loading && !error && data === null,
+    executionCount,
+    lastExecutedAt
+  };
+}
+
+// Batch execution hook
+export function useAUIToolBatch<TInput = any, TOutput = any>(
+  tool: AUITool<TInput, TOutput>,
+  options: UseAUIToolOptions<TInput, TOutput> = {}
+) {
+  const [results, setResults] = useState<Map<string, TOutput>>(new Map());
+  const [errors, setErrors] = useState<Map<string, Error>>(new Map());
+  const [loading, setLoading] = useState(false);
+  
+  const executeBatch = useCallback(async (inputs: TInput[]): Promise<Map<string, TOutput>> => {
+    setLoading(true);
+    const newResults = new Map<string, TOutput>();
+    const newErrors = new Map<string, Error>();
+    
+    try {
+      const promises = inputs.map(async (input, index) => {
+        const key = JSON.stringify(input);
+        try {
+          const context: AUIContext = {
+            cache: new Map(),
+            fetch: globalThis.fetch,
+            isServer: typeof window === 'undefined',
+            ...options.context
+          };
+          
+          const result = await tool.run(input, context);
+          newResults.set(key, result);
+          return result;
+        } catch (error) {
+          newErrors.set(key, error as Error);
+          throw error;
+        }
+      });
+      
+      await Promise.allSettled(promises);
+      
+      setResults(newResults);
+      setErrors(newErrors);
+      
+      return newResults;
+    } finally {
+      setLoading(false);
+    }
+  }, [tool, options.context]);
+  
+  return {
+    executeBatch,
+    results,
+    errors,
+    loading
+  };
+}
+
+// Export all hooks
+export { useAUIToolEnhanced as default };

package/lib/aui/hooks/useAUITools.ts

@@ -0,0 +1,195 @@
+'use client';
+
+import { useState, useCallback, useRef } from 'react';
+import aui, { AUITool, AUIContext } from '../index';
+
+export interface UseAUIToolsOptions {
+  cache?: boolean;
+  optimistic?: boolean;
+  retry?: number;
+  onSuccess?: (result: any, tool: string) => void;
+  onError?: (error: Error, tool: string) => void;
+}
+
+export function useAUITools(options: UseAUIToolsOptions = {}) {
+  const [loading, setLoading] = useState<Record<string, boolean>>({});
+  const [errors, setErrors] = useState<Record<string, Error | null>>({});
+  const [data, setData] = useState<Record<string, any>>({});
+  const cache = useRef(new Map<string, any>());
+
+  const execute = useCallback(async <TInput = any, TOutput = any>(
+    toolName: string,
+    input: TInput
+  ): Promise<TOutput | null> => {
+    setLoading(prev => ({ ...prev, [toolName]: true }));
+    setErrors(prev => ({ ...prev, [toolName]: null }));
+
+    try {
+      // Check cache if enabled
+      if (options.cache) {
+        const cacheKey = `${toolName}:${JSON.stringify(input)}`;
+        if (cache.current.has(cacheKey)) {
+          const cached = cache.current.get(cacheKey);
+          setData(prev => ({ ...prev, [toolName]: cached }));
+          setLoading(prev => ({ ...prev, [toolName]: false }));
+          return cached;
+        }
+      }
+
+      // Create context
+      const ctx: AUIContext = {
+        cache: cache.current,
+        fetch: globalThis.fetch,
+        isServer: false,
+      };
+
+      // Get tool
+      const tool = aui.get(toolName);
+      let result: TOutput;
+
+      if (tool) {
+        // Execute locally if tool exists
+        result = await tool.run(input, ctx);
+      } else {
+        // Execute via API
+        const response = await fetch(`/api/tools/${toolName}`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify(input),
+        });
+
+        if (!response.ok) {
+          throw new Error(`Failed to execute tool: ${response.statusText}`);
+        }
+
+        const data = await response.json();
+        result = data.data;
+      }
+
+      // Cache result if enabled
+      if (options.cache) {
+        const cacheKey = `${toolName}:${JSON.stringify(input)}`;
+        cache.current.set(cacheKey, result);
+      }
+
+      setData(prev => ({ ...prev, [toolName]: result }));
+      options.onSuccess?.(result, toolName);
+      
+      return result;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error('Unknown error');
+      setErrors(prev => ({ ...prev, [toolName]: err }));
+      options.onError?.(err, toolName);
+      
+      // Retry logic
+      if (options.retry && options.retry > 0) {
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        return execute(toolName, input);
+      }
+      
+      return null;
+    } finally {
+      setLoading(prev => ({ ...prev, [toolName]: false }));
+    }
+  }, [options]);
+
+  const executeBatch = useCallback(async (
+    executions: Array<{ tool: string; input: any }>
+  ) => {
+    setLoading(prev => {
+      const newLoading = { ...prev };
+      executions.forEach(exec => {
+        newLoading[exec.tool] = true;
+      });
+      return newLoading;
+    });
+
+    try {
+      const response = await fetch('/api/aui/batch', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ executions }),
+      });
+
+      if (!response.ok) {
+        throw new Error('Batch execution failed');
+      }
+
+      const { results } = await response.json();
+      
+      results.forEach((result: any) => {
+        if (result.success) {
+          setData(prev => ({ ...prev, [result.tool]: result.data }));
+          setErrors(prev => ({ ...prev, [result.tool]: null }));
+          options.onSuccess?.(result.data, result.tool);
+        } else {
+          const error = new Error(result.error);
+          setErrors(prev => ({ ...prev, [result.tool]: error }));
+          options.onError?.(error, result.tool);
+        }
+      });
+
+      return results;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error('Batch execution failed');
+      executions.forEach(exec => {
+        setErrors(prev => ({ ...prev, [exec.tool]: err }));
+      });
+      throw err;
+    } finally {
+      setLoading(prev => {
+        const newLoading = { ...prev };
+        executions.forEach(exec => {
+          newLoading[exec.tool] = false;
+        });
+        return newLoading;
+      });
+    }
+  }, [options]);
+
+  const reset = useCallback((toolName?: string) => {
+    if (toolName) {
+      setData(prev => ({ ...prev, [toolName]: undefined }));
+      setErrors(prev => ({ ...prev, [toolName]: null }));
+      setLoading(prev => ({ ...prev, [toolName]: false }));
+    } else {
+      setData({});
+      setErrors({});
+      setLoading({});
+      cache.current.clear();
+    }
+  }, []);
+
+  const clearCache = useCallback(() => {
+    cache.current.clear();
+  }, []);
+
+  return {
+    execute,
+    executeBatch,
+    loading,
+    errors,
+    data,
+    reset,
+    clearCache,
+    isLoading: (tool: string) => loading[tool] || false,
+    getError: (tool: string) => errors[tool] || null,
+    getData: (tool: string) => data[tool],
+  };
+}
+
+export function useAUITool<TInput = any, TOutput = any>(
+  toolOrName: string | AUITool<TInput, TOutput>,
+  options?: UseAUIToolsOptions
+) {
+  const toolName = typeof toolOrName === 'string' ? toolOrName : toolOrName.name;
+  const tools = useAUITools(options);
+
+  return {
+    execute: (input: TInput) => tools.execute<TInput, TOutput>(toolName, input),
+    loading: tools.isLoading(toolName),
+    error: tools.getError(toolName),
+    data: tools.getData(toolName) as TOutput | undefined,
+    reset: () => tools.reset(toolName),
+  };
+}

package/lib/aui/index.ts

@@ -0,0 +1,156 @@
+import { AUITool, AUIContext, ToolConfig } from './core';
+
+export { AUITool } from './core';
+export type { AUIContext, ToolConfig } from './core';
+
+export class AUI {
+  private tools = new Map<string, AUITool>();
+
+  tool(name: string): AUITool {
+    const t = new AUITool(name);
+    this.tools.set(name, t);
+    return t;
+  }
+
+  get(name: string): AUITool | undefined {
+    return this.tools.get(name);
+  }
+
+  getTool(name: string): AUITool | undefined {
+    return this.tools.get(name);
+  }
+
+  async execute<TInput = any, TOutput = any>(
+    name: string,
+    input: TInput,
+    ctx?: AUIContext
+  ): Promise<TOutput> {
+    const tool = this.get(name);
+    if (!tool) throw new Error(`Tool "${name}" not found`);
+    return await tool.run(input, ctx || this.createContext());
+  }
+
+  createContext(additions?: Partial<AUIContext>): AUIContext {
+    return {
+      cache: new Map(),
+      fetch: globalThis.fetch?.bind(globalThis) || (() => Promise.reject(new Error('Fetch not available'))),
+      isServer: typeof window === 'undefined',
+      ...additions,
+    };
+  }
+
+  list(): AUITool[] {
+    return Array.from(this.tools.values());
+  }
+
+  getTools(): AUITool[] {
+    return this.list();
+  }
+
+  getToolNames(): string[] {
+    return Array.from(this.tools.keys());
+  }
+
+  has(name: string): boolean {
+    return this.tools.has(name);
+  }
+
+  clear(): void {
+    this.tools.clear();
+  }
+
+  remove(name: string): boolean {
+    return this.tools.delete(name);
+  }
+  
+  findByTag(tag: string): AUITool[] {
+    return this.list().filter(tool => tool.tags.includes(tag));
+  }
+  
+  findByTags(...tags: string[]): AUITool[] {
+    return this.list().filter(tool => 
+      tags.every(tag => tool.tags.includes(tag))
+    );
+  }
+}
+
+const aui: AUI = new AUI();
+
+export type InferToolInput<T> = T extends AUITool<infer I, any> ? I : never;
+export type InferToolOutput<T> = T extends AUITool<any, infer O> ? O : never;
+
+export type ToolDefinition<TInput = any, TOutput = any> = {
+  tool: AUITool<TInput, TOutput>;
+  input: TInput;
+  output: TOutput;
+};
+
+export type ExtractTools<T> = T extends { [K in keyof T]: AUITool<infer I, infer O> }
+  ? { [K in keyof T]: ToolDefinition<InferToolInput<T[K]>, InferToolOutput<T[K]>> }
+  : never;
+
+// Re-export everything for convenience
+export { z } from 'zod';
+export { useAUITool, useAUI } from './hooks/useAUITool';
+export { useAUITools } from './hooks/useAUITools';
+export { AUIProvider, useAUIContext, useAUIInstance } from './provider';
+export { 
+  createAITool, 
+  AIControlledTool, 
+  aiControlSystem,
+  aiTools,
+  type AIControlOptions 
+} from './ai-control';
+
+// Export all pre-built tools
+export * from './tools';
+
+// Client control exports
+export { 
+  clientTools, 
+  clientControlSystem, 
+  createClientControlSystem,
+  type ClientControlContext 
+} from './client-control';
+
+// Tool registry and discovery
+export { 
+  ToolRegistry,
+  ToolDiscovery,
+  globalToolRegistry,
+  toolDiscovery,
+  type ToolMetadata
+} from './tool-registry';
+
+// Client executor for optimized client-side execution
+export {
+  ClientExecutor,
+  clientExecutor,
+  executeClientTool,
+  type ClientExecutorOptions,
+  type CacheStrategy
+} from './client-executor';
+
+// AI Assistant integration
+export {
+  AIAssistant,
+  createAIAssistant,
+  formatToolForLLM,
+  assistants,
+  type AIAssistantConfig,
+  type AIToolCall,
+  type AIConversationMessage
+} from './ai-assistant';
+
+// Vercel AI SDK integration
+export {
+  convertToVercelTool,
+  createVercelTools,
+  createAUIToolFromVercel,
+  executeToolWithStreaming,
+  vercelAIIntegration
+} from './vercel-ai';
+
+// Example tools - exported separately to avoid circular dependencies
+
+export default aui;