@lantos1618/better-ui 0.2.3 → 0.4.0

package/lib/aui/hooks/useAUIToolEnhanced.ts

@@ -1,343 +0,0 @@
-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

@@ -1,195 +0,0 @@
-'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

@@ -1,156 +0,0 @@
-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;