@lantos1618/better-ui 0.1.0

package/lib/aui/tools/state-tools.tsx

@@ -0,0 +1,209 @@
+import { z } from 'zod';
+import { createAITool } from '../ai-control';
+
+const globalState = new Map<string, any>();
+const stateListeners = new Map<string, Set<(value: any) => void>>();
+
+export const stateSet = createAITool('state.set')
+  .describe('Set a value in global state')
+  .tag('state', 'storage', 'client')
+  .input(z.object({
+    key: z.string(),
+    value: z.any(),
+    persist: z.boolean().optional()
+  }))
+  .clientExecute(async ({ input }) => {
+    globalState.set(input.key, input.value);
+    
+    if (input.persist && typeof window !== 'undefined') {
+      localStorage.setItem(`aui_state_${input.key}`, JSON.stringify(input.value));
+    }
+    
+    const listeners = stateListeners.get(input.key);
+    if (listeners) {
+      listeners.forEach(listener => listener(input.value));
+    }
+    
+    return { key: input.key, value: input.value, persisted: input.persist };
+  });
+
+export const stateGet = createAITool('state.get')
+  .describe('Get a value from global state')
+  .tag('state', 'storage', 'client')
+  .input(z.object({
+    key: z.string(),
+    fallback: z.any().optional()
+  }))
+  .clientExecute(async ({ input }) => {
+    let value = globalState.get(input.key);
+    
+    if (value === undefined && typeof window !== 'undefined') {
+      const stored = localStorage.getItem(`aui_state_${input.key}`);
+      if (stored) {
+        value = JSON.parse(stored);
+        globalState.set(input.key, value);
+      }
+    }
+    
+    return { 
+      key: input.key, 
+      value: value !== undefined ? value : input.fallback,
+      found: value !== undefined
+    };
+  });
+
+export const stateDelete = createAITool('state.delete')
+  .describe('Delete a value from global state')
+  .tag('state', 'storage', 'client')
+  .input(z.object({
+    key: z.string()
+  }))
+  .clientExecute(async ({ input }) => {
+    const existed = globalState.has(input.key);
+    globalState.delete(input.key);
+    
+    if (typeof window !== 'undefined') {
+      localStorage.removeItem(`aui_state_${input.key}`);
+    }
+    
+    return { key: input.key, deleted: existed };
+  });
+
+export const stateClear = createAITool('state.clear')
+  .describe('Clear all state')
+  .tag('state', 'storage', 'client')
+  .input(z.object({
+    includePersisted: z.boolean().optional()
+  }))
+  .clientExecute(async ({ input }) => {
+    const size = globalState.size;
+    globalState.clear();
+    
+    if (input.includePersisted && typeof window !== 'undefined') {
+      const keys = Object.keys(localStorage);
+      keys.forEach(key => {
+        if (key.startsWith('aui_state_')) {
+          localStorage.removeItem(key);
+        }
+      });
+    }
+    
+    return { cleared: size };
+  });
+
+export const stateSubscribe = createAITool('state.subscribe')
+  .describe('Subscribe to state changes')
+  .tag('state', 'reactive', 'client')
+  .input(z.object({
+    key: z.string(),
+    immediate: z.boolean().optional()
+  }))
+  .clientExecute(async ({ input }) => {
+    if (!stateListeners.has(input.key)) {
+      stateListeners.set(input.key, new Set());
+    }
+    
+    const subscriptionId = Math.random().toString(36).substring(7);
+    
+    return {
+      subscriptionId,
+      key: input.key,
+      subscribe: (callback: (value: any) => void) => {
+        stateListeners.get(input.key)?.add(callback);
+        
+        if (input.immediate) {
+          const currentValue = globalState.get(input.key);
+          if (currentValue !== undefined) {
+            callback(currentValue);
+          }
+        }
+        
+        return () => {
+          stateListeners.get(input.key)?.delete(callback);
+        };
+      }
+    };
+  });
+
+export const cookieSet = createAITool('cookie.set')
+  .describe('Set a cookie')
+  .tag('state', 'cookie', 'client')
+  .input(z.object({
+    name: z.string(),
+    value: z.string(),
+    expires: z.number().optional(),
+    path: z.string().optional(),
+    domain: z.string().optional(),
+    secure: z.boolean().optional(),
+    sameSite: z.enum(['strict', 'lax', 'none']).optional()
+  }))
+  .clientExecute(async ({ input }) => {
+    let cookie = `${input.name}=${encodeURIComponent(input.value)}`;
+    
+    if (input.expires) {
+      const date = new Date();
+      date.setTime(date.getTime() + input.expires);
+      cookie += `; expires=${date.toUTCString()}`;
+    }
+    
+    if (input.path) cookie += `; path=${input.path}`;
+    if (input.domain) cookie += `; domain=${input.domain}`;
+    if (input.secure) cookie += '; secure';
+    if (input.sameSite) cookie += `; samesite=${input.sameSite}`;
+    
+    document.cookie = cookie;
+    
+    return { name: input.name, value: input.value, set: true };
+  });
+
+export const cookieGet = createAITool('cookie.get')
+  .describe('Get a cookie value')
+  .tag('state', 'cookie', 'client')
+  .input(z.object({
+    name: z.string()
+  }))
+  .clientExecute(async ({ input }) => {
+    const cookies = document.cookie.split(';');
+    for (const cookie of cookies) {
+      const [name, value] = cookie.trim().split('=');
+      if (name === input.name) {
+        return { name: input.name, value: decodeURIComponent(value), found: true };
+      }
+    }
+    return { name: input.name, value: null, found: false };
+  });
+
+export const sessionSet = createAITool('session.set')
+  .describe('Set a value in session storage')
+  .tag('state', 'session', 'client')
+  .input(z.object({
+    key: z.string(),
+    value: z.any()
+  }))
+  .clientExecute(async ({ input }) => {
+    if (typeof window === 'undefined') {
+      throw new Error('Session storage not available');
+    }
+    
+    sessionStorage.setItem(input.key, JSON.stringify(input.value));
+    return { key: input.key, value: input.value };
+  });
+
+export const sessionGet = createAITool('session.get')
+  .describe('Get a value from session storage')
+  .tag('state', 'session', 'client')
+  .input(z.object({
+    key: z.string()
+  }))
+  .clientExecute(async ({ input }) => {
+    if (typeof window === 'undefined') {
+      throw new Error('Session storage not available');
+    }
+    
+    const value = sessionStorage.getItem(input.key);
+    return { 
+      key: input.key, 
+      value: value ? JSON.parse(value) : null,
+      found: value !== null
+    };
+  });

package/lib/aui/types.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import { ReactElement } from 'react';
+
+export interface AUIContext {
+  cache: Map<string, any>;
+  fetch: typeof fetch;
+  user?: any;
+  session?: any;
+  env?: Record<string, string>;
+  headers?: HeadersInit;
+  cookies?: Record<string, string>;
+  isServer?: boolean;
+}
+
+export type ExecuteFunction<TInput, TOutput> = (params: {
+  input: TInput;
+  ctx?: AUIContext;
+}) => Promise<TOutput> | TOutput;
+
+export type ClientExecuteFunction<TInput, TOutput> = (params: {
+  input: TInput;
+  ctx: AUIContext;
+}) => Promise<TOutput> | TOutput;
+
+export type RenderFunction<TInput, TOutput> = (props: {
+  data: TOutput;
+  input?: TInput;
+  loading?: boolean;
+  error?: Error;
+}) => ReactElement;
+
+export type MiddlewareFunction<TInput, TOutput> = (params: {
+  input: TInput;
+  ctx: AUIContext;
+  next: () => Promise<TOutput>;
+}) => Promise<TOutput>;
+
+export interface ToolConfig<TInput, TOutput> {
+  name: string;
+  inputSchema?: z.ZodType<TInput>;
+  executeHandler?: ExecuteFunction<TInput, TOutput>;
+  clientHandler?: ClientExecuteFunction<TInput, TOutput>;
+  renderHandler?: RenderFunction<TInput, TOutput>;
+  middleware?: Array<MiddlewareFunction<TInput, TOutput>>;
+  description?: string;
+  tags?: string[];
+}

package/lib/aui/vercel-ai.ts

@@ -0,0 +1,100 @@
+import { AUITool, AUIContext } from './core';
+import aui from './index';
+import { z } from 'zod';
+
+export function convertToVercelTool<TInput = any, TOutput = any>(
+  auiTool: AUITool<TInput, TOutput>
+): any {
+  const config = auiTool.getConfig();
+  
+  const vercelToolDefinition = {
+    description: config.description || `Execute ${config.name} tool`,
+    parameters: config.inputSchema || z.any(),
+    execute: async (input: any) => {
+      const ctx = aui.createContext();
+      return await auiTool.run(input as TInput, ctx);
+    }
+  };
+  
+  return vercelToolDefinition;
+}
+
+export function createVercelTools(tools: AUITool[]): Record<string, any> {
+  const vercelTools: Record<string, any> = {};
+  
+  tools.forEach(tool => {
+    vercelTools[tool.name] = convertToVercelTool(tool);
+  });
+  
+  return vercelTools;
+}
+
+export function createAUIToolFromVercel<TInput = any, TOutput = any>(
+  name: string,
+  vercelToolDef: {
+    description?: string;
+    parameters: z.ZodType<TInput>;
+    execute: (input: TInput) => Promise<TOutput> | TOutput;
+  }
+): AUITool<TInput, TOutput> {
+  const tool = aui
+    .tool(name)
+    .input(vercelToolDef.parameters)
+    .execute(async ({ input }) => vercelToolDef.execute(input));
+  
+  if (vercelToolDef.description) {
+    tool.describe(vercelToolDef.description);
+  }
+  
+  return tool;
+}
+
+export async function executeToolWithStreaming<TInput, TOutput>(
+  tool: AUITool<TInput, TOutput>,
+  input: TInput,
+  onStream?: (chunk: any) => void
+): Promise<TOutput> {
+  const ctx = aui.createContext();
+  
+  if (onStream) {
+    const originalFetch = ctx.fetch;
+    ctx.fetch = async (...args) => {
+      const response = await originalFetch(...args);
+      
+      if (response.body && response.headers.get('content-type')?.includes('text/event-stream')) {
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          
+          const chunk = decoder.decode(value);
+          onStream(chunk);
+        }
+      }
+      
+      return response;
+    };
+  }
+  
+  return await tool.run(input, ctx);
+}
+
+export const vercelAIIntegration = {
+  convertToVercelTool,
+  createVercelTools,
+  createAUIToolFromVercel,
+  executeToolWithStreaming,
+  
+  getAllVercelTools() {
+    const tools = aui.getTools();
+    return createVercelTools(tools);
+  },
+  
+  registerWithVercelAI(tools: AUITool[]) {
+    return createVercelTools(tools);
+  }
+};
+
+export default vercelAIIntegration;

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@lantos1618/better-ui",
+  "version": "0.1.0",
+  "description": "A modern UI framework for building AI-powered applications",
+  "main": "lib/aui/index.ts",
+  "types": "lib/aui/index.ts",
+  "files": [
+    "lib/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "ui",
+    "framework",
+    "ai",
+    "react",
+    "nextjs"
+  ],
+  "author": "Lyndon Leong",
+  "license": "MIT",
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "lint": "eslint .",
+    "test": "jest",
+    "type-check": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@ai-sdk/openai": "^2.0.20",
+    "@sendgrid/mail": "^8.1.5",
+    "ai": "^5.0.23",
+    "next": "^15.5.0",
+    "react": "^18.3.0",
+    "react-dom": "^18.3.0",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@eslint/eslintrc": "^3.3.1",
+    "@jest/globals": "^29.7.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^20",
+    "@types/react": "^18",
+    "@types/react-dom": "^18",
+    "eslint": "^8",
+    "eslint-config-next": "14.2.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.4.1",
+    "typescript": "^5"
+  }
+}