asasvirtuais 0.1.0

package/packages/chat/settings.tsx

@@ -0,0 +1,98 @@
+'use client'
+import { UpdateForm, useSingle, useTable } from '@/app/module'
+import { Dialog, Button, VStack, Menu, Portal, useDisclosure, Spinner, HStack, Text } from '@chakra-ui/react'
+import React, { useState, useCallback, useMemo } from 'react'
+import { ModelSelector } from './model-selector'
+import { TemperatureSlider } from './temperature-slider'
+import { useParams } from 'next/navigation'
+
+export function SettingsDialog() {
+  const { id } = useParams()
+  const { index } = useTable('chats')
+  const chat = useMemo(() => index[id as keyof typeof index], [id, index])
+  const { open, onOpen, onClose } = useDisclosure()
+
+  if (!chat)
+    return null
+  
+  return (
+    <>
+      <Menu.Item value="settings" onClick={onOpen}>
+        Settings <Menu.ItemCommand>⚙️</Menu.ItemCommand>
+      </Menu.Item>
+      
+      <Dialog.Root open={open} onOpenChange={(e) => !e.open && onClose()}>
+        <Portal>
+          <Dialog.Backdrop />
+          <Dialog.Positioner>
+            <Dialog.Content>
+              <Dialog.Header>
+                <Dialog.Title>Chat Settings</Dialog.Title>
+                <Dialog.CloseTrigger />
+              </Dialog.Header>
+              
+              <UpdateForm 
+                table="chats" 
+                id={chat.id} 
+                defaults={{ 
+                  model: chat.model || 'openrouter/auto',
+                  temperature: chat.temperature || 1
+                }}
+              >
+                {(props) => {
+                  return (
+                    <form onSubmit={async (e: React.FormEvent) => {
+                      await props.submit(e)
+                      onClose()
+                    }}>
+                      <Dialog.Body>
+                        <VStack gap={6} align="stretch">
+                          {/* Model Selection */}
+                          <ModelSelector
+                            value={props.fields.model ?? 'openrouter/auto'}
+                            onValueChange={value => props.setField('model', value)}
+                          />
+
+                          {/* Temperature Slider */}
+                          <TemperatureSlider
+                            value={props.fields.temperature ?? 1}
+                            onValueChangeEnd={value => props.setField('temperature', value)}
+                          />
+                        </VStack>
+                      </Dialog.Body>
+                      
+                      <Dialog.Footer>
+                        <HStack gap={2}>
+                          <Dialog.CloseTrigger asChild>
+                            <Button variant="outline" disabled={props.loading}>
+                              Cancel
+                            </Button>
+                          </Dialog.CloseTrigger>
+                          
+                          <Button
+                            type='submit'
+                            colorPalette="blue" 
+                            disabled={props.loading}
+                          >
+                            {props.loading ? (
+                              <>
+                                <Spinner size="sm" />
+                                Saving...
+                              </>
+                            ) : (
+                              'Save Changes'
+                            )}
+                          </Button>
+                        </HStack>
+                      </Dialog.Footer>
+                    </form>
+                  )
+                }}
+              </UpdateForm>
+            </Dialog.Content>
+          </Dialog.Positioner>
+        </Portal>
+      </Dialog.Root>
+    </>
+  )
+}

package/packages/chat/temperature-slider.tsx

@@ -0,0 +1,67 @@
+'use client'
+import { useState, useEffect, useCallback, memo } from 'react'
+import { VStack, HStack, Text, Slider } from '@chakra-ui/react'
+
+interface TemperatureSliderProps {
+  value: number
+  onValueChangeEnd: (value: number) => void
+}
+
+// Memoize the component to prevent re-renders unless props change
+export const TemperatureSlider = memo(function TemperatureSlider({ value, onValueChangeEnd }: TemperatureSliderProps) {
+  // Use local state for immediate feedback
+  const [localValue, setLocalValue] = useState(value || 1)
+  
+  // Update local value when prop changes (e.g., when settings are loaded)
+  useEffect(() => {
+    setLocalValue(value || 1)
+  }, [value])
+  
+  // Handle value change - only updates local state
+  const handleValueChange = useCallback((values: { value: number[] }) => {
+    setLocalValue(values.value[0])
+  }, [])
+  
+  // Handle drag end - updates parent
+  const handleValueChangeEnd = useCallback(() => {
+    onValueChangeEnd(localValue)
+  }, [localValue, onValueChangeEnd])
+  
+  return (
+    <VStack align="stretch" gap={2}>
+      <HStack justify="space-between">
+        <Text fontWeight="medium">Temperature</Text>
+        <Text fontSize="sm" color="gray.600">
+          {localValue.toFixed(1)}
+        </Text>
+      </HStack>
+      
+      <Text fontSize="sm" color="gray.600">
+        Controls randomness: lower is more focused, higher is more creative
+      </Text>
+      
+      <Slider.Root
+        value={[localValue]}
+        onValueChange={handleValueChange}
+        onValueChangeEnd={handleValueChangeEnd}
+        min={0}
+        max={2}
+        step={0.1}
+      >
+        <Slider.Control>
+          <Slider.Track>
+            <Slider.Range />
+          </Slider.Track>
+          <Slider.Thumb index={0}>
+            <Slider.HiddenInput />
+          </Slider.Thumb>
+        </Slider.Control>
+        <HStack justify="space-between" fontSize="xs" color="gray.500" mt={1}>
+          <Text>0 (Focused)</Text>
+          <Text>1 (Balanced)</Text>
+          <Text>2 (Creative)</Text>
+        </HStack>
+      </Slider.Root>
+    </VStack>
+  )
+})

package/packages/chat/tool-results.tsx

@@ -0,0 +1,32 @@
+'use client'
+import React from 'react'
+import { clientTools } from '@/app/tools'
+
+export function ToolResults({ tools }: { tools: Record<string, any> }) {
+  return (
+    <div style={{ display: 'grid', gap: 8 }}>
+      {Object.entries(tools).map(([tool, data]) => (
+        <ToolResult key={tool} tool={tool} data={data} />
+      ))}
+    </div>
+  )
+}
+
+export function ToolResult({ tool, data }: { tool: string, data: any }) {
+  const module = clientTools[tool]
+  if (module?.View) {
+    const View = module.View
+    return (
+      <div>
+        <div style={{ fontSize: 12, color: '#6b7280', marginBottom: 4 }}>{tool}</div>
+        <View data={data} />
+      </div>
+    )
+  }
+  return (
+    <div>
+      <div style={{ fontSize: 12, color: '#6b7280', marginBottom: 4 }}>{tool}</div>
+      <pre style={{ whiteSpace: 'pre-wrap' }}>{JSON.stringify(data, null, 2)}</pre>
+    </div>
+  )
+}

package/packages/crud/core.ts

@@ -0,0 +1,75 @@
+import z from "zod"
+
+// Core query types for consistent querying across all backends
+export type BasicOperators<T, K extends keyof T> = {
+  '$ne'?: T[K]
+  '$in'?: T[K][]
+  '$nin'?: T[K][]
+  '$lt'?: T[K]
+  '$lte'?: T[K]
+  '$gt'?: T[K]
+  '$gte'?: T[K]
+}
+
+export type Filters<T> = {
+  '$limit'?: number
+  '$skip'?: number
+  '$sort'?: {
+    [K in keyof T]?: 1 | -1
+  }
+  '$select'?: Array<keyof T>
+}
+
+export type Query<T = any> = {
+  [K in keyof T]?: T[K] | BasicOperators<T, K>
+} & Filters<T> & {
+  '$or'?: Array<Query<T>>
+  '$and'?: Array<Query<T>>
+}
+
+export type Operators<T, K extends keyof T> = BasicOperators<T, K> & {
+  '$or'?: Array<Query<T>>
+  '$and'?: Array<Query<T>>
+}
+
+// Core CRUD operations using props pattern
+export interface FindProps {
+  table?: string
+  id: string
+}
+
+export interface CreateProps<T = any> {
+  table?: string
+  data: T
+}
+
+export interface UpdateProps<T = any> {
+  table?: string
+  id: string
+  data: Partial<T>
+}
+
+export interface RemoveProps {
+  table?: string
+  id: string
+}
+
+export interface ListProps<T = any> {
+  table?: string
+  query?: Query<T>
+}
+
+export interface DatabaseInterface {
+  [T: string]: {
+    readable: z.SomeZodObject,
+    writable: z.SomeZodObject
+  }
+}
+
+export interface TableInterface<Readable, Writable = Readable> {
+  find   (props: FindProps ): Promise<Readable>
+  create (props: CreateProps<Writable> ): Promise<Readable>
+  update (props: UpdateProps<Writable> ): Promise<Readable>
+  remove (props: RemoveProps ): Promise<Readable>
+  list   (props: ListProps<Readable> ): Promise<Readable[]>
+}

package/packages/crud/fetcher.ts

@@ -0,0 +1,64 @@
+import z from 'zod'
+import type { DatabaseInterface, FindProps, CreateProps, UpdateProps, RemoveProps, ListProps, TableInterface } from './core'
+
+export interface FetcherConfig {
+  baseUrl?: string
+  headers?: Record<string, string>
+}
+
+export function tableInterface<Schema extends DatabaseInterface, Table extends keyof Schema>({
+  schema,
+  defaultTable,
+  baseUrl = '/api/v1',
+  headers = {}
+} : {
+  schema: Schema,
+  defaultTable?: Table,
+  baseUrl?: string,
+  headers?: Record<string, string>
+} ): TableInterface<z.infer<Schema[keyof Schema]['readable']>, z.infer<Schema[keyof Schema]['writable']>>{
+
+  return {
+    async find({ table = defaultTable as string, id }) {
+      const response = await fetch(`${baseUrl}/${table}/${id}`, {
+        headers
+      })
+      return response.json()
+    },
+
+    async create({ table = defaultTable as string, data }) {
+      console.log(baseUrl, table, data)
+      const response = await fetch(`${baseUrl}/${table}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...headers },
+        body: JSON.stringify(data)
+      })
+      return response.json()
+    },
+
+    async update({ table = defaultTable as string, id, data }){
+      const response = await fetch(`${baseUrl}/${table}/${id}`, {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json', ...headers },
+        body: JSON.stringify(data)
+      })
+      return response.json()
+    },
+
+    async remove({ table = defaultTable as string, id }){
+      const response = await fetch(`${baseUrl}/${table}/${id}`, {
+        method: 'DELETE',
+        headers
+      })
+      return response.json()
+    },
+
+    async list({ table = defaultTable as string, query }){
+      const params = new URLSearchParams(query as any)
+      const response = await fetch(`${baseUrl}/${table}?${params}`, {
+        headers
+      })
+      return response.json()
+    }
+  }
+}

package/packages/crud/index.ts

@@ -0,0 +1,2 @@
+export * from './core'
+export * from './fetcher'

package/packages/crud/next.ts

@@ -0,0 +1,128 @@
+import { NextRequest } from 'next/server'
+import { DatabaseInterface, TableInterface } from './core'
+
+export function routes(implementation: TableInterface<any, any>) {
+  return {
+    // GET /api/v1/[table]/[id]
+    find: (
+      request: NextRequest,
+      { params }: { params: Promise<{ table: string; id: string }> }
+    ) =>
+      handleRoute(request, params, ({ table, id }) =>
+        implementation.find({ table, id })
+      ),
+
+    // GET /api/v1/[table]
+    list: (
+      request: NextRequest,
+      { params }: { params: Promise<{ table: string }> }
+    ) =>
+      handleRoute(request, params, ({ table }) => {
+        const url = new URL(request.url)
+        const query = Object.fromEntries(url.searchParams)
+        return implementation.list({ table, query })
+      }),
+
+    // POST /api/v1/[table]
+    create: (
+      request: NextRequest,
+      { params }: { params: Promise<{ table: string }> }
+    ) =>
+      handleRoute(request, params, async ({ table }) => {
+        const data = await request.json()
+        return implementation.create({ table, data })
+      }),
+
+    // PATCH /api/v1/[table]/[id]
+    update: (
+      request: NextRequest,
+      { params }: { params: Promise<{ table: string; id: string }> }
+    ) =>
+      handleRoute(request, params, async ({ table, id }) => {
+        const data = await request.json()
+        return implementation.update({ table, id, data })
+      }),
+
+    // DELETE /api/v1/[table]/[id]
+    remove: (
+      request: NextRequest,
+      { params }: { params: Promise<{ table: string; id: string }> }
+    ) =>
+      handleRoute(request, params, ({ table, id }) =>
+        implementation.remove({ table, id })
+      ),
+  }
+}
+
+export async function handleRoute<P, R>(
+  request: NextRequest,
+  params: Promise<P>,
+  handler: (resolvedParams: any) => Promise<R>
+) {
+  try {
+    const resolvedParams = await params
+    const result = await handler(resolvedParams)
+    return Response.json(result)
+  } catch (error) {
+    console.error("Route error:", error)
+    return Response.json(
+      { error: error instanceof Error ? error.message : "Unknown error" },
+      { status: 500 }
+    )
+  }
+}
+
+// Utility for creating a single dynamic route handler
+export function createDynamicRoute(implementation: TableInterface<any, any>) {
+  const routeHandlers = routes(implementation)
+
+  return async function dynamicRoute(
+    request: NextRequest,
+    { params: promise }: { params: Promise<{ params: string[] }> }
+  ) {
+    const { params } = await promise
+    const [table, id] = params
+
+    const method = request.method
+
+    try {
+      switch (method) {
+        case "GET":
+          if (id) {
+            return routeHandlers.find(request, {
+              params: Promise.resolve({ table, id }),
+            })
+          } else {
+            return routeHandlers.list(request, {
+              params: Promise.resolve({
+                table,
+                ...Object.fromEntries(request.nextUrl.searchParams.entries()),
+              }),
+            })
+          }
+        case "POST":
+          return routeHandlers.create(request, {
+            params: Promise.resolve({ table }),
+          })
+        case "PATCH":
+          if (!id) throw new Error("ID required for PATCH")
+          return routeHandlers.update(request, {
+            params: Promise.resolve({ table, id }),
+          })
+        case "DELETE":
+          if (!id) throw new Error("ID required for DELETE")
+          return routeHandlers.remove(request, {
+            params: Promise.resolve({ table, id }),
+          })
+        default:
+          return Response.json({ error: "Method not allowed" }, { status: 405 })
+      }
+    } catch (error) {
+      console.error(error)
+      return Response.json(
+        { error: error instanceof Error ? error.message : "Unknown error" },
+        { status: 500 }
+      )
+    }
+  }
+}