@geenius/ai 0.1.0 → 0.3.1

package/packages/solidjs-css/src/components/ChatWindow.tsx

@@ -1,78 +0,0 @@
-// @geenius-ai/solidjs — src/components/ChatWindow.tsx
-
-/**
- * SolidJS chat window component.
- */
-
-import { createSignal, For, Show, type Component, type JSX } from 'solid-js'
-import type { AIChatMessage } from '@geenius-ai/shared'
-import { createChat, type CreateChatOptions } from '../primitives/createChat'
-
-export interface SolidChatWindowProps extends CreateChatOptions {
-    className?: string
-    renderMessage?: (message: AIChatMessage) => JSX.Element
-}
-
-export const ChatWindow: Component<SolidChatWindowProps> = (props) => {
-    const [input, setInput] = createSignal('')
-    const chat = createChat(props)
-
-    const handleSubmit = async (e: Event) => {
-        e.preventDefault()
-        const content = input().trim()
-        if (!content || chat.isSending()) return
-        setInput('')
-        await chat.sendMessage(content)
-    }
-
-    return (
-        <div class={props.className} data-ai-component="chat-window">
-            <div data-ai-messages>
-                <Show when={chat.messages().length === 0}>
-                    <div data-ai-empty><p>Start a conversation</p></div>
-                </Show>
-
-                <For each={chat.messages()}>
-                    {(msg) => props.renderMessage ? props.renderMessage(msg) : (
-                        <div data-ai-message data-ai-role={msg.role}>
-                            <div data-ai-message-role>{msg.role}</div>
-                            <div data-ai-message-content>{msg.content}</div>
-                        </div>
-                    )}
-                </For>
-
-                <Show when={chat.isSending()}>
-                    <div data-ai-message data-ai-role="assistant" data-ai-loading>
-                        <span>Thinking…</span>
-                    </div>
-                </Show>
-            </div>
-
-            <Show when={chat.error()}>
-                <div data-ai-error role="alert">
-                    <span>{chat.error()}</span>
-                    <button onClick={chat.clearError}>×</button>
-                </div>
-            </Show>
-
-            <form onSubmit={handleSubmit} data-ai-input-form>
-                <textarea
-                    value={input()}
-                    onInput={(e) => setInput(e.currentTarget.value)}
-                    placeholder="Type a message…"
-                    disabled={chat.isSending()}
-                    data-ai-input
-                    onKeyDown={(e) => {
-                        if (e.key === 'Enter' && !e.shiftKey) {
-                            e.preventDefault()
-                            handleSubmit(e)
-                        }
-                    }}
-                />
-                <button type="submit" disabled={chat.isSending() || !input().trim()} data-ai-send>
-                    {chat.isSending() ? 'Sending…' : 'Send'}
-                </button>
-            </form>
-        </div>
-    )
-}

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

@@ -1,62 +0,0 @@
-// @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-css/src/components/ModelTestRunner.tsx

@@ -1,119 +0,0 @@
-// @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-css/src/components/index.ts

@@ -1,5 +0,0 @@
-// @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-css/src/index.ts

@@ -1,26 +0,0 @@
-// @geenius-ai/solidjs-css — Independent barrel (vanilla CSS variant)
-// ALL imports from LOCAL files + @geenius-ai/shared — NOT from @geenius-ai/solidjs
-
-// 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-css/src/pages/ChatPage.tsx

@@ -1,22 +0,0 @@
-// @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-css/src/pages/ModelTestPage.tsx

@@ -1,22 +0,0 @@
-// @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-css/src/pages/index.ts

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

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

@@ -1,79 +0,0 @@
-// @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-css/src/primitives/createChat.ts

@@ -1,100 +0,0 @@
-// @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-css/src/primitives/createContentManager.ts

@@ -1,61 +0,0 @@
-// @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-css/src/primitives/createImageGeneration.ts

@@ -1,46 +0,0 @@
-// @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),
-    }
-}