@geenius/ai 0.1.0

package/packages/solidjs/src/components/GenerationCard.tsx

@@ -0,0 +1,62 @@
+// @geenius-ai/solidjs — src/components/GenerationCard.tsx
+
+/**
+ * SolidJS generation result card.
+ */
+
+import { Show, type Component } from 'solid-js'
+import type { AIGenerationType } from '@geenius-ai/shared'
+
+export interface SolidGenerationCardProps {
+    type: AIGenerationType
+    content: string
+    model?: string
+    durationMs?: number
+    tokens?: number
+    cost?: number
+    error?: string
+    className?: string
+}
+
+export const GenerationCard: Component<SolidGenerationCardProps> = (props) => {
+    return (
+        <div class={props.className} data-ai-component="generation-card" data-ai-type={props.type}>
+            <div data-ai-card-header>
+                <span data-ai-card-type>{props.type}</span>
+                <Show when={props.model}><span data-ai-card-model>{props.model}</span></Show>
+                <Show when={props.durationMs != null}><span data-ai-card-duration>{props.durationMs}ms</span></Show>
+            </div>
+
+            <Show when={props.error} fallback={
+                <div data-ai-card-content>
+                    <Show when={props.type === 'image'}
+                        fallback={
+                            <Show when={props.type === 'audio' || props.type === 'speech'}
+                                fallback={<pre data-ai-card-text>{props.content}</pre>}
+                            >
+                                <audio controls data-ai-card-audio>
+                                    <source src={props.content.startsWith('http') ? props.content : `data:audio/mp3;base64,${props.content}`} />
+                                </audio>
+                            </Show>
+                        }
+                    >
+                        <img
+                            src={props.content.startsWith('http') ? props.content : `data:image/png;base64,${props.content}`}
+                            alt="AI Generated"
+                            data-ai-card-image
+                        />
+                    </Show>
+                </div>
+            }>
+                <div data-ai-card-error role="alert">{props.error}</div>
+            </Show>
+
+            <Show when={props.tokens || props.cost != null}>
+                <div data-ai-card-footer>
+                    <Show when={props.tokens}><span>{props.tokens} tokens</span></Show>
+                    <Show when={props.cost != null}><span>${props.cost!.toFixed(4)}</span></Show>
+                </div>
+            </Show>
+        </div>
+    )
+}

package/packages/solidjs/src/components/ModelTestRunner.tsx

@@ -0,0 +1,119 @@
+// @geenius-ai/solidjs — src/components/ModelTestRunner.tsx
+
+/**
+ * SolidJS model test runner with tabs.
+ */
+
+import { createSignal, For, Show, type Component } from 'solid-js'
+import type { AIGenerationType } from '@geenius-ai/shared'
+import { createModelTest, type CreateModelTestOptions, type ModelTestResult } from '../primitives/createModelTest'
+
+export interface SolidModelTestRunnerProps extends CreateModelTestOptions {
+    className?: string
+    availableModels?: string[]
+    defaultTab?: AIGenerationType
+}
+
+const TABS: { id: AIGenerationType; label: string }[] = [
+    { id: 'text', label: 'Text' },
+    { id: 'image', label: 'Image' },
+    { id: 'audio', label: 'Audio' },
+    { id: 'transcription', label: 'ASR' },
+    { id: 'video', label: 'Video' },
+]
+
+export const ModelTestRunner: Component<SolidModelTestRunnerProps> = (props) => {
+    const [activeTab, setActiveTab] = createSignal<AIGenerationType>(props.defaultTab ?? 'text')
+    const [prompt, setPrompt] = createSignal('')
+    const [selectedModel, setSelectedModel] = createSignal('')
+    const [batchMode, setBatchMode] = createSignal(false)
+
+    const test = createModelTest(props)
+
+    const handleSubmit = async (e: Event) => {
+        e.preventDefault()
+        if (!prompt().trim()) return
+        if (batchMode() && props.availableModels) {
+            await test.runBatchTest(props.availableModels, prompt().trim())
+        } else if (selectedModel()) {
+            await test.runTest(selectedModel(), prompt().trim(), activeTab())
+        }
+    }
+
+    return (
+        <div class={props.className} data-ai-component="model-test-runner">
+            <div data-ai-tabs role="tablist">
+                <For each={TABS}>
+                    {(tab) => (
+                        <button
+                            role="tab"
+                            aria-selected={activeTab() === tab.id}
+                            onClick={() => setActiveTab(tab.id)}
+                            data-ai-tab
+                        >
+                            {tab.label}
+                        </button>
+                    )}
+                </For>
+            </div>
+
+            <form onSubmit={handleSubmit} data-ai-test-form>
+                <select
+                    value={selectedModel()}
+                    onChange={(e) => setSelectedModel(e.currentTarget.value)}
+                    disabled={test.isRunning() || batchMode()}
+                    data-ai-input
+                >
+                    <option value="">Select model…</option>
+                    <For each={props.availableModels ?? []}>
+                        {(m) => <option value={m}>{m}</option>}
+                    </For>
+                </select>
+
+                <textarea
+                    value={prompt()}
+                    onInput={(e) => setPrompt(e.currentTarget.value)}
+                    placeholder="Enter test prompt…"
+                    disabled={test.isRunning()}
+                    data-ai-input
+                />
+
+                <div data-ai-actions>
+                    <label>
+                        <input
+                            type="checkbox"
+                            checked={batchMode()}
+                            onChange={(e) => setBatchMode(e.currentTarget.checked)}
+                        />
+                        Test all models
+                    </label>
+                    <button type="submit" disabled={test.isRunning() || !prompt().trim()} data-ai-submit>
+                        {test.isRunning() ? 'Running…' : 'Run Test'}
+                    </button>
+                    <Show when={test.results().length > 0}>
+                        <button type="button" onClick={test.clearResults} data-ai-clear>Clear</button>
+                    </Show>
+                </div>
+            </form>
+
+            <Show when={test.results().length > 0}>
+                <div data-ai-test-results>
+                    <For each={test.results()}>
+                        {(result) => (
+                            <div data-ai-test-result data-ai-status={result.error ? 'error' : 'success'}>
+                                <div data-ai-result-header>
+                                    <span>{result.model}</span>
+                                    <span>{result.durationMs}ms</span>
+                                    <Show when={result.error}><span data-ai-result-error>{result.error}</span></Show>
+                                </div>
+                                <Show when={!result.error}>
+                                    <pre data-ai-result-text>{result.result}</pre>
+                                </Show>
+                            </div>
+                        )}
+                    </For>
+                </div>
+            </Show>
+        </div>
+    )
+}

package/packages/solidjs/src/components/index.ts

@@ -0,0 +1,5 @@
+// @geenius-ai/solidjs — src/components/index.ts
+
+export { ChatWindow, type SolidChatWindowProps } from './ChatWindow'
+export { ModelTestRunner, type SolidModelTestRunnerProps } from './ModelTestRunner'
+export { GenerationCard, type SolidGenerationCardProps } from './GenerationCard'

package/packages/solidjs/src/index.ts

@@ -0,0 +1,32 @@
+// @geenius-ai/solidjs — src/index.ts
+
+/**
+ * @geenius-ai/solidjs
+ *
+ * SolidJS primitives, components, and pages for AI-powered
+ * Convex applications.
+ */
+
+// Primitives — Core
+export { createAI, type CreateAIOptions, type CreateAIReturn } from './primitives/createAI'
+export { createChat, type CreateChatOptions, type CreateChatReturn } from './primitives/createChat'
+export { createModelTest, type CreateModelTestOptions, type CreateModelTestReturn, type ModelTestResult } from './primitives/createModelTest'
+
+// Primitives — Multi-modal
+export { createImageGeneration, type CreateImageGenerationOptions, type GeneratedImage } from './primitives/createImageGeneration'
+export { createTextToSpeech, type CreateTextToSpeechOptions } from './primitives/createTextToSpeech'
+export { createVideoGeneration, type CreateVideoGenerationOptions, type GeneratedVideo } from './primitives/createVideoGeneration'
+
+// Primitives — Content, Memory, Skills
+export { createContentManager, type CreateContentManagerOptions } from './primitives/createContentManager'
+export { createMemory, type CreateMemoryOptions } from './primitives/createMemory'
+export { createSkills, type CreateSkillsOptions } from './primitives/createSkills'
+
+// Components
+export { ChatWindow, type SolidChatWindowProps } from './components/ChatWindow'
+export { ModelTestRunner, type SolidModelTestRunnerProps } from './components/ModelTestRunner'
+export { GenerationCard, type SolidGenerationCardProps } from './components/GenerationCard'
+
+// Pages
+export { ChatPage, type SolidChatPageProps } from './pages/ChatPage'
+export { ModelTestPage, type SolidModelTestPageProps } from './pages/ModelTestPage'

package/packages/solidjs/src/pages/ChatPage.tsx

@@ -0,0 +1,22 @@
+// @geenius-ai/solidjs — src/pages/ChatPage.tsx
+
+import { createSignal, type Component } from 'solid-js'
+import { ChatWindow, type SolidChatWindowProps } from '../components/ChatWindow'
+
+export interface SolidChatPageProps extends Omit<SolidChatWindowProps, 'className'> {
+    className?: string
+}
+
+export const ChatPage: Component<SolidChatPageProps> = (props) => {
+    const [_, setConversationId] = createSignal<string | undefined>(undefined)
+
+    return (
+        <div class={props.className} data-ai-page="chat">
+            <div data-ai-page-header>
+                <h1 data-ai-page-title>AI Chat</h1>
+                <button onClick={() => setConversationId(undefined)} data-ai-new-chat>New Chat</button>
+            </div>
+            <ChatWindow {...props} />
+        </div>
+    )
+}

package/packages/solidjs/src/pages/ModelTestPage.tsx

@@ -0,0 +1,22 @@
+// @geenius-ai/solidjs — src/pages/ModelTestPage.tsx
+
+import { type Component } from 'solid-js'
+import { ModelTestRunner, type SolidModelTestRunnerProps } from '../components/ModelTestRunner'
+import { DEFAULT_MODELS } from '@geenius-ai/shared'
+
+export interface SolidModelTestPageProps extends SolidModelTestRunnerProps {
+    title?: string
+}
+
+export const ModelTestPage: Component<SolidModelTestPageProps> = (props) => {
+    const models = props.availableModels ?? DEFAULT_MODELS.map(m => m.id)
+
+    return (
+        <div class={props.className} data-ai-page="model-test">
+            <div data-ai-page-header>
+                <h1 data-ai-page-title>{props.title ?? 'Model Test Lab'}</h1>
+            </div>
+            <ModelTestRunner {...props} availableModels={models} />
+        </div>
+    )
+}

package/packages/solidjs/src/pages/index.ts

@@ -0,0 +1,4 @@
+// @geenius-ai/solidjs — src/pages/index.ts
+
+export { ChatPage, type SolidChatPageProps } from './ChatPage'
+export { ModelTestPage, type SolidModelTestPageProps } from './ModelTestPage'

package/packages/solidjs/src/primitives/createAI.ts

@@ -0,0 +1,79 @@
+// @geenius-ai/solidjs — src/primitives/createAI.ts
+
+/**
+ * Core AI primitive — signal-based multi-modal generation.
+ */
+
+import { createSignal } from 'solid-js'
+import type { AIGenerationType } from '@geenius-ai/shared'
+
+export interface CreateAIOptions {
+    /** Convex action caller for text */
+    callGenerateText?: (args: any) => Promise<string>
+    callGenerateImage?: (args: any) => Promise<string>
+    callGenerateAudio?: (args: any) => Promise<string>
+    callTranscribeAudio?: (args: any) => Promise<string>
+    callGenerateVideo?: (args: any) => Promise<string>
+}
+
+export interface CreateAIReturn {
+    generateText: (args: { model: string; messages: any[]; temperature?: number; maxTokens?: number; caller?: string }) => Promise<string>
+    generateImage: (prompt: string, model?: string) => Promise<string>
+    generateAudio: (prompt: string, voice?: string) => Promise<string>
+    transcribeAudio: (audio: string) => Promise<string>
+    generateVideo: (prompt: string) => Promise<string>
+    isLoading: () => boolean
+    error: () => string | null
+    lastResult: () => string | null
+    lastType: () => AIGenerationType | null
+    clearError: () => void
+}
+
+export function createAI(options: CreateAIOptions = {}): CreateAIReturn {
+    const [isLoading, setIsLoading] = createSignal(false)
+    const [error, setError] = createSignal<string | null>(null)
+    const [lastResult, setLastResult] = createSignal<string | null>(null)
+    const [lastType, setLastType] = createSignal<AIGenerationType | null>(null)
+
+    async function wrap(type: AIGenerationType, fn: () => Promise<string>): Promise<string> {
+        setIsLoading(true)
+        setError(null)
+        try {
+            const result = await fn()
+            setLastResult(result)
+            setLastType(type)
+            return result
+        } catch (err) {
+            const msg = err instanceof Error ? err.message : `${type} generation failed`
+            setError(msg)
+            throw err
+        } finally {
+            setIsLoading(false)
+        }
+    }
+
+    return {
+        generateText: (args) => wrap('text', () => {
+            if (!options.callGenerateText) throw new Error('callGenerateText not provided')
+            return options.callGenerateText(args)
+        }),
+        generateImage: (prompt, model) => wrap('image', () => {
+            if (!options.callGenerateImage) throw new Error('callGenerateImage not provided')
+            return options.callGenerateImage({ prompt, model })
+        }),
+        generateAudio: (prompt, voice) => wrap('audio', () => {
+            if (!options.callGenerateAudio) throw new Error('callGenerateAudio not provided')
+            return options.callGenerateAudio({ prompt, voice })
+        }),
+        transcribeAudio: (audio) => wrap('transcription', () => {
+            if (!options.callTranscribeAudio) throw new Error('callTranscribeAudio not provided')
+            return options.callTranscribeAudio({ audio })
+        }),
+        generateVideo: (prompt) => wrap('video', () => {
+            if (!options.callGenerateVideo) throw new Error('callGenerateVideo not provided')
+            return options.callGenerateVideo({ prompt })
+        }),
+        isLoading, error, lastResult, lastType,
+        clearError: () => setError(null),
+    }
+}

package/packages/solidjs/src/primitives/createChat.ts

@@ -0,0 +1,100 @@
+// @geenius-ai/solidjs — src/primitives/createChat.ts
+
+/**
+ * Chat primitive — signal-based conversation management.
+ */
+
+import { createSignal } from 'solid-js'
+import type { AIChatMessage } from '@geenius-ai/shared'
+
+export interface CreateChatOptions {
+    model?: string
+    systemPrompt?: string
+    callSendMessage?: (args: any) => Promise<void>
+    callGenerateText?: (args: any) => Promise<string>
+    callCreateConversation?: (args: any) => Promise<string>
+    onNewConversation?: (id: string) => void
+}
+
+export interface CreateChatReturn {
+    messages: () => AIChatMessage[]
+    isSending: () => boolean
+    error: () => string | null
+    conversationId: () => string | null
+    sendMessage: (content: string) => Promise<void>
+    clearError: () => void
+}
+
+export function createChat(options: CreateChatOptions = {}): CreateChatReturn {
+    const [messages, setMessages] = createSignal<AIChatMessage[]>([])
+    const [isSending, setIsSending] = createSignal(false)
+    const [error, setError] = createSignal<string | null>(null)
+    const [conversationId, setConversationId] = createSignal<string | null>(null)
+
+    async function sendMessage(content: string) {
+        setIsSending(true)
+        setError(null)
+
+        try {
+            let activeId = conversationId()
+
+            if (!activeId && options.callCreateConversation) {
+                activeId = await options.callCreateConversation({
+                    title: content.substring(0, 100),
+                    model: options.model ?? 'gpt-4o',
+                    systemPrompt: options.systemPrompt,
+                })
+                setConversationId(activeId)
+                options.onNewConversation?.(activeId!)
+            }
+
+            // Add user message locally
+            const userMsg: AIChatMessage = {
+                id: `msg-${Date.now()}`,
+                conversationId: activeId ?? 'local',
+                userId: 'local',
+                role: 'user',
+                content,
+                createdAt: Date.now(),
+            }
+            setMessages(prev => [...prev, userMsg])
+
+            if (options.callSendMessage && activeId) {
+                await options.callSendMessage({ conversationId: activeId, content })
+            }
+
+            // Generate AI response
+            if (options.callGenerateText) {
+                const allMessages = messages()
+                const aiResponse = await options.callGenerateText({
+                    model: options.model ?? 'gpt-4o',
+                    messages: [
+                        ...(options.systemPrompt ? [{ role: 'system', content: options.systemPrompt }] : []),
+                        ...allMessages.map(m => ({ role: m.role, content: m.content })),
+                    ],
+                    caller: 'chat',
+                })
+
+                const assistantMsg: AIChatMessage = {
+                    id: `msg-${Date.now()}-ai`,
+                    conversationId: activeId ?? 'local',
+                    userId: 'ai',
+                    role: 'assistant',
+                    content: aiResponse,
+                    model: options.model ?? 'gpt-4o',
+                    createdAt: Date.now(),
+                }
+                setMessages(prev => [...prev, assistantMsg])
+            }
+        } catch (err) {
+            setError(err instanceof Error ? err.message : 'Failed to send message')
+        } finally {
+            setIsSending(false)
+        }
+    }
+
+    return {
+        messages, isSending, error, conversationId, sendMessage,
+        clearError: () => setError(null),
+    }
+}

package/packages/solidjs/src/primitives/createContentManager.ts

@@ -0,0 +1,61 @@
+// @geenius-ai/solidjs — src/primitives/createContentManager.ts
+
+import { createSignal } from 'solid-js'
+import type {
+    ContentAction,
+    ContentTone,
+    ContentType,
+    ContentGenerateOptions,
+    ContentResult,
+} from '@geenius-ai/shared'
+
+export interface CreateContentManagerOptions {
+    generateFn: (options: ContentGenerateOptions) => Promise<ContentResult>
+    defaultType?: ContentType
+    defaultTone?: ContentTone
+    defaultModel?: string
+}
+
+export function createContentManager(options: CreateContentManagerOptions) {
+    const { generateFn, defaultType = 'text', defaultTone, defaultModel } = options
+    const [result, setResult] = createSignal<ContentResult | null>(null)
+    const [isGenerating, setIsGenerating] = createSignal(false)
+    const [error, setError] = createSignal<Error | null>(null)
+
+    const execute = async (action: ContentAction, input: string, extra?: Partial<ContentGenerateOptions>) => {
+        setIsGenerating(true)
+        setError(null)
+        try {
+            const res = await generateFn({
+                action,
+                input,
+                type: extra?.type ?? defaultType,
+                tone: extra?.tone ?? defaultTone,
+                model: extra?.model ?? defaultModel,
+                ...extra,
+            })
+            setResult(res)
+            return res
+        } catch (err) {
+            const e = err instanceof Error ? err : new Error(String(err))
+            setError(e)
+            throw e
+        } finally {
+            setIsGenerating(false)
+        }
+    }
+
+    return {
+        generate: (input: string, opts?: Partial<ContentGenerateOptions>) => execute('generate', input, opts),
+        rewrite: (text: string, instructions?: string) => execute('rewrite', text, { instructions }),
+        translate: (text: string, language: string) => execute('translate', text, { language }),
+        summarize: (text: string) => execute('summarize', text),
+        variations: (text: string, count: number = 3) => execute('variations', text, { variations: count }),
+        changeTone: (text: string, tone: ContentTone) => execute('change-tone', text, { tone }),
+        proofread: (text: string) => execute('proofread', text),
+        result,
+        isGenerating,
+        error,
+        reset: () => { setResult(null); setError(null) },
+    }
+}

package/packages/solidjs/src/primitives/createImageGeneration.ts

@@ -0,0 +1,46 @@
+// @geenius-ai/solidjs — src/primitives/createImageGeneration.ts
+
+import { createSignal } from 'solid-js'
+
+export interface GeneratedImage {
+    url: string
+    prompt: string
+    model: string
+    timestamp: number
+}
+
+export interface CreateImageGenerationOptions {
+    callGenerateImage: (args: any) => Promise<string>
+    defaultModel?: string
+}
+
+export function createImageGeneration(options: CreateImageGenerationOptions) {
+    const [images, setImages] = createSignal<GeneratedImage[]>([])
+    const [isGenerating, setIsGenerating] = createSignal(false)
+    const [error, setError] = createSignal<string | null>(null)
+
+    async function generate(prompt: string, opts?: {
+        model?: string; size?: string; quality?: 'standard' | 'hd'; negativePrompt?: string; seed?: number
+    }) {
+        setIsGenerating(true)
+        setError(null)
+        try {
+            const model = opts?.model ?? options.defaultModel ?? 'dall-e-3'
+            const result = await options.callGenerateImage({ prompt, model, ...opts })
+            const url = result.startsWith('http') ? result : `data:image/png;base64,${result}`
+            setImages(prev => [{ url, prompt, model, timestamp: Date.now() }, ...prev])
+            return url
+        } catch (err) {
+            setError(err instanceof Error ? err.message : 'Image generation failed')
+            throw err
+        } finally {
+            setIsGenerating(false)
+        }
+    }
+
+    return {
+        generate, images, isGenerating, error,
+        clearImages: () => setImages([]),
+        clearError: () => setError(null),
+    }
+}