@geenius/ai 0.1.0

package/packages/react/src/hooks/useAI.ts

@@ -0,0 +1,158 @@
+// @geenius-ai/react — src/hooks/useAI.ts
+
+/**
+ * Core AI hook — generate text/image/audio/video with loading state.
+ */
+
+import { useState, useCallback } from 'react'
+import { useAction } from 'convex/react'
+import type { AIGenerationType } from '@geenius-ai/shared'
+
+// Stable no-op placeholder for optional Convex action references.
+// Ensures hooks are always called unconditionally (React Rules of Hooks).
+const _noop = (() => Promise.resolve(null)) as any
+
+export interface UseAIOptions {
+    /** Convex action reference for text generation (api.ai.generateText) */
+    generateTextAction?: any
+    /** Convex action reference for image generation */
+    generateImageAction?: any
+    /** Convex action reference for audio generation */
+    generateAudioAction?: any
+    /** Convex action reference for transcription */
+    transcribeAudioAction?: any
+    /** Convex action reference for video generation */
+    generateVideoAction?: any
+}
+
+export interface UseAIReturn {
+    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 useAI(options: UseAIOptions = {}): UseAIReturn {
+    const [isLoading, setIsLoading] = useState(false)
+    const [error, setError] = useState<string | null>(null)
+    const [lastResult, setLastResult] = useState<string | null>(null)
+    const [lastType, setLastType] = useState<AIGenerationType | null>(null)
+
+    // Always call hooks unconditionally; gate actual invocations on options presence
+    const textAction = useAction(options.generateTextAction ?? _noop)
+    const imageAction = useAction(options.generateImageAction ?? _noop)
+    const audioAction = useAction(options.generateAudioAction ?? _noop)
+    const transcribeAction = useAction(options.transcribeAudioAction ?? _noop)
+    const videoAction = useAction(options.generateVideoAction ?? _noop)
+
+    const generateText = useCallback(async (args: {
+        model: string; messages: any[]; temperature?: number; maxTokens?: number; caller?: string
+    }) => {
+        if (!options.generateTextAction) throw new Error('generateTextAction not provided')
+        setIsLoading(true)
+        setError(null)
+        try {
+            const result = await textAction(args)
+            setLastResult(result)
+            setLastType('text')
+            return result
+        } catch (err) {
+            const msg = err instanceof Error ? err.message : 'Text generation failed'
+            setError(msg)
+            throw err
+        } finally {
+            setIsLoading(false)
+        }
+    }, [textAction])
+
+    const generateImage = useCallback(async (prompt: string, model?: string) => {
+        if (!options.generateImageAction) throw new Error('generateImageAction not provided')
+        setIsLoading(true)
+        setError(null)
+        try {
+            const result = await imageAction({ prompt, model })
+            setLastResult(result)
+            setLastType('image')
+            return result
+        } catch (err) {
+            const msg = err instanceof Error ? err.message : 'Image generation failed'
+            setError(msg)
+            throw err
+        } finally {
+            setIsLoading(false)
+        }
+    }, [imageAction])
+
+    const generateAudio = useCallback(async (prompt: string, voice?: string) => {
+        if (!options.generateAudioAction) throw new Error('generateAudioAction not provided')
+        setIsLoading(true)
+        setError(null)
+        try {
+            const result = await audioAction({ prompt, voice })
+            setLastResult(result)
+            setLastType('audio')
+            return result
+        } catch (err) {
+            const msg = err instanceof Error ? err.message : 'Audio generation failed'
+            setError(msg)
+            throw err
+        } finally {
+            setIsLoading(false)
+        }
+    }, [audioAction])
+
+    const transcribeAudio = useCallback(async (audio: string) => {
+        if (!options.transcribeAudioAction) throw new Error('transcribeAudioAction not provided')
+        setIsLoading(true)
+        setError(null)
+        try {
+            const result = await transcribeAction({ audio })
+            setLastResult(result)
+            setLastType('transcription')
+            return result
+        } catch (err) {
+            const msg = err instanceof Error ? err.message : 'Transcription failed'
+            setError(msg)
+            throw err
+        } finally {
+            setIsLoading(false)
+        }
+    }, [transcribeAction])
+
+    const generateVideo = useCallback(async (prompt: string) => {
+        if (!options.generateVideoAction) throw new Error('generateVideoAction not provided')
+        setIsLoading(true)
+        setError(null)
+        try {
+            const result = await videoAction({ prompt })
+            setLastResult(result)
+            setLastType('video')
+            return result
+        } catch (err) {
+            const msg = err instanceof Error ? err.message : 'Video generation failed'
+            setError(msg)
+            throw err
+        } finally {
+            setIsLoading(false)
+        }
+    }, [videoAction])
+
+    const clearError = useCallback(() => setError(null), [])
+
+    return {
+        generateText, generateImage, generateAudio, transcribeAudio, generateVideo,
+        isLoading, error, lastResult, lastType, clearError,
+    }
+}

package/packages/react/src/hooks/useAILogs.ts

@@ -0,0 +1,40 @@
+// @geenius-ai/react — src/hooks/useAILogs.ts
+
+/**
+ * Hook for querying AI logs with filters.
+ */
+
+import { useQuery } from 'convex/react'
+import type { AILogEntry, AIRequestStatus } from '@geenius-ai/shared'
+
+export interface UseAILogsOptions {
+    /** Query reference: api.ai.listLogs */
+    listLogsQuery: any
+    filters?: {
+        model?: string
+        provider?: string
+        status?: AIRequestStatus
+        caller?: string
+    }
+    limit?: number
+}
+
+export interface UseAILogsReturn {
+    logs: AILogEntry[]
+    isLoading: boolean
+}
+
+export function useAILogs(options: UseAILogsOptions): UseAILogsReturn {
+    const logs = useQuery(options.listLogsQuery, {
+        model: options.filters?.model,
+        provider: options.filters?.provider,
+        status: options.filters?.status,
+        caller: options.filters?.caller,
+        limit: options.limit ?? 50,
+    })
+
+    return {
+        logs: (logs ?? []) as AILogEntry[],
+        isLoading: logs === undefined,
+    }
+}

package/packages/react/src/hooks/useAIModels.ts

@@ -0,0 +1,53 @@
+// @geenius-ai/react — src/hooks/useAIModels.ts
+
+/**
+ * Hook for managing AI models and providers.
+ */
+
+import { useQuery, useMutation } from 'convex/react'
+import { useCallback } from 'react'
+import type { AIModel } from '@geenius-ai/shared'
+
+// Stable no-op for optional Convex mutation references (Rules of Hooks)
+const _noop = (() => Promise.resolve(null)) as any
+
+export interface UseAIModelsOptions {
+    /** Query reference: api.ai.listModels */
+    listModelsQuery: any
+    /** Mutation reference: api.ai.upsertModel */
+    upsertModelMutation?: any
+}
+
+export interface UseAIModelsReturn {
+    models: AIModel[]
+    isLoading: boolean
+    upsertModel: (model: Partial<AIModel> & { id: string; provider: string }) => Promise<void>
+}
+
+export function useAIModels(options: UseAIModelsOptions): UseAIModelsReturn {
+    const models = useQuery(options.listModelsQuery, {})
+    // Always call useMutation unconditionally (React Rules of Hooks)
+    const upsertMutation = useMutation(options.upsertModelMutation ?? _noop)
+
+    const upsertModel = useCallback(async (
+        model: Partial<AIModel> & { id: string; provider: string },
+    ) => {
+        if (!options.upsertModelMutation) throw new Error('upsertModelMutation not provided')
+        await upsertMutation({
+            model: model.id,
+            provider: model.provider,
+            displayName: model.displayName,
+            inputCostPer1k: model.inputCostPer1k ?? 0,
+            outputCostPer1k: model.outputCostPer1k ?? 0,
+            capabilities: model.capabilities,
+            contextWindow: model.contextWindow,
+            isActive: model.isActive,
+        })
+    }, [upsertMutation, options.upsertModelMutation])
+
+    return {
+        models: (models ?? []) as AIModel[],
+        isLoading: models === undefined,
+        upsertModel,
+    }
+}

package/packages/react/src/hooks/useChat.ts

@@ -0,0 +1,141 @@
+// @geenius-ai/react — src/hooks/useChat.ts
+
+/**
+ * Chat conversation hook — manages messages, sends messages,
+ * and tracks conversation state.
+ */
+
+import { useState, useCallback, useRef, useEffect } from 'react'
+import { useQuery, useMutation, useAction, skipToken } from 'convex/react'
+import type { AIChatMessage, AIMessageRole } from '@geenius-ai/shared'
+
+// Stable no-op for optional Convex mutation/action refs (React Rules of Hooks)
+const _noop = (() => Promise.resolve(null)) as any
+
+export interface UseChatOptions {
+    conversationId?: string
+    /** Query reference: api.ai.getConversation */
+    getConversationQuery?: any
+    /** Query reference: api.ai.listMessages */
+    listMessagesQuery?: any
+    /** Mutation reference: api.ai.sendMessage */
+    sendMessageMutation?: any
+    /** Action reference: api.ai.generateText (for AI response) */
+    generateTextAction?: any
+    /** Mutation reference: api.ai.createConversation */
+    createConversationMutation?: any
+    model?: string
+    systemPrompt?: string
+    onNewConversation?: (id: string) => void
+}
+
+export interface UseChatReturn {
+    messages: AIChatMessage[]
+    isLoading: boolean
+    isSending: boolean
+    error: string | null
+    sendMessage: (content: string) => Promise<void>
+    conversationId: string | null
+    clearError: () => void
+}
+
+export function useChat(options: UseChatOptions = {}): UseChatReturn {
+    const [localMessages, setLocalMessages] = useState<AIChatMessage[]>([])
+    const [isSending, setIsSending] = useState(false)
+    const [error, setError] = useState<string | null>(null)
+    const [conversationId, setConversationId] = useState<string | null>(options.conversationId ?? null)
+
+    // Always call Convex hooks unconditionally (React Rules of Hooks).
+    // skipToken skips the query when no ref or no conversationId is available.
+    const convexMessages = useQuery(
+        options.listMessagesQuery ?? skipToken,
+        options.listMessagesQuery && conversationId ? { conversationId } : skipToken,
+    )
+    const sendMutation = useMutation(options.sendMessageMutation ?? _noop)
+    const createConversation = useMutation(options.createConversationMutation ?? _noop)
+    const textAction = useAction(options.generateTextAction ?? _noop)
+
+    const messages = convexMessages ?? localMessages
+
+    const sendMessage = useCallback(async (content: string) => {
+        setIsSending(true)
+        setError(null)
+
+        try {
+            let activeConversationId = conversationId
+
+            // Create conversation if needed
+            if (!activeConversationId && options.createConversationMutation) {
+                activeConversationId = await createConversation({
+                    title: content.substring(0, 100),
+                    model: options.model ?? 'gpt-4o',
+                    systemPrompt: options.systemPrompt,
+                })
+                setConversationId(activeConversationId)
+                if (activeConversationId) options.onNewConversation?.(activeConversationId)
+            }
+
+            // Add user message
+            if (options.sendMessageMutation && activeConversationId) {
+                await sendMutation({ conversationId: activeConversationId, content })
+            } else {
+                // Local-only mode
+                const userMsg: AIChatMessage = {
+                    id: `msg-${Date.now()}`,
+                    conversationId: activeConversationId ?? 'local',
+                    userId: 'local',
+                    role: 'user',
+                    content,
+                    createdAt: Date.now(),
+                }
+                setLocalMessages(prev => [...prev, userMsg])
+            }
+
+            // Generate AI response if action provided
+            if (options.generateTextAction) {
+                const aiResponse = await textAction({
+                    model: options.model ?? 'gpt-4o',
+                    messages: [
+                        ...(options.systemPrompt
+                            ? [{ role: 'system', content: options.systemPrompt }]
+                            : []),
+                        ...(messages as AIChatMessage[]).map((m: AIChatMessage) => ({ role: m.role, content: m.content })),
+                        { role: 'user', content },
+                    ],
+                    caller: 'chat',
+                })
+
+                // If local-only, add the response too
+                if (!options.sendMessageMutation) {
+                    const assistantMsg: AIChatMessage = {
+                        id: `msg-${Date.now()}-ai`,
+                        conversationId: activeConversationId ?? 'local',
+                        userId: 'ai',
+                        role: 'assistant',
+                        content: aiResponse,
+                        model: options.model ?? 'gpt-4o',
+                        createdAt: Date.now(),
+                    }
+                    setLocalMessages(prev => [...prev, assistantMsg])
+                }
+            }
+        } catch (err) {
+            const msg = err instanceof Error ? err.message : 'Failed to send message'
+            setError(msg)
+        } finally {
+            setIsSending(false)
+        }
+    }, [conversationId, sendMutation, createConversation, textAction, messages, options])
+
+    const clearError = useCallback(() => setError(null), [])
+
+    return {
+        messages: messages as AIChatMessage[],
+        isLoading: convexMessages === undefined && !!options.listMessagesQuery,
+        isSending,
+        error,
+        sendMessage,
+        conversationId,
+        clearError,
+    }
+}

package/packages/react/src/hooks/useContentManager.ts

@@ -0,0 +1,108 @@
+// @geenius-ai/react — src/hooks/useContentManager.ts
+
+import { useState, useCallback } from 'react'
+import type {
+    ContentAction,
+    ContentTone,
+    ContentType,
+    ContentGenerateOptions,
+    ContentResult,
+    ContentTemplate,
+} from '@geenius-ai/shared'
+
+export interface UseContentManagerOptions {
+    /** Convex action for content generation */
+    generateFn: (options: ContentGenerateOptions) => Promise<ContentResult>
+    /** Default content type */
+    defaultType?: ContentType
+    /** Default tone */
+    defaultTone?: ContentTone
+    /** Default model */
+    defaultModel?: string
+}
+
+export interface UseContentManagerReturn {
+    /** Generate content */
+    generate: (input: string, options?: Partial<ContentGenerateOptions>) => Promise<ContentResult>
+    /** Rewrite content */
+    rewrite: (text: string, instructions?: string) => Promise<ContentResult>
+    /** Translate content */
+    translate: (text: string, language: string) => Promise<ContentResult>
+    /** Summarize content */
+    summarize: (text: string) => Promise<ContentResult>
+    /** Generate variations */
+    variations: (text: string, count?: number) => Promise<ContentResult>
+    /** Change tone */
+    changeTone: (text: string, tone: ContentTone) => Promise<ContentResult>
+    /** Proofread */
+    proofread: (text: string) => Promise<ContentResult>
+    /** Current result */
+    result: ContentResult | null
+    /** Loading state */
+    isGenerating: boolean
+    /** Error state */
+    error: Error | null
+    /** Clear state */
+    reset: () => void
+}
+
+export function useContentManager(options: UseContentManagerOptions): UseContentManagerReturn {
+    const { generateFn, defaultType = 'text', defaultTone, defaultModel } = options
+    const [result, setResult] = useState<ContentResult | null>(null)
+    const [isGenerating, setIsGenerating] = useState(false)
+    const [error, setError] = useState<Error | null>(null)
+
+    const execute = useCallback(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)
+        }
+    }, [generateFn, defaultType, defaultTone, defaultModel])
+
+    const generate = useCallback((input: string, opts?: Partial<ContentGenerateOptions>) =>
+        execute('generate', input, opts), [execute])
+
+    const rewrite = useCallback((text: string, instructions?: string) =>
+        execute('rewrite', text, { instructions }), [execute])
+
+    const translate = useCallback((text: string, language: string) =>
+        execute('translate', text, { language }), [execute])
+
+    const summarize = useCallback((text: string) =>
+        execute('summarize', text), [execute])
+
+    const variations = useCallback((text: string, count: number = 3) =>
+        execute('variations', text, { variations: count }), [execute])
+
+    const changeTone = useCallback((text: string, tone: ContentTone) =>
+        execute('change-tone', text, { tone }), [execute])
+
+    const proofread = useCallback((text: string) =>
+        execute('proofread', text), [execute])
+
+    const reset = useCallback(() => {
+        setResult(null)
+        setError(null)
+    }, [])
+
+    return {
+        generate, rewrite, translate, summarize, variations, changeTone, proofread,
+        result, isGenerating, error, reset,
+    }
+}

package/packages/react/src/hooks/useImageGeneration.ts

@@ -0,0 +1,82 @@
+// @geenius-ai/react — src/hooks/useImageGeneration.ts
+
+/**
+ * Image generation hook (DALL-E, SDXL, Flux, etc.)
+ */
+
+import { useState, useCallback } from 'react'
+import { useAction } from 'convex/react'
+
+export interface GeneratedImage {
+    url: string
+    prompt: string
+    model: string
+    timestamp: number
+}
+
+export interface UseImageGenerationOptions {
+    generateImageAction: any
+    defaultModel?: string
+}
+
+export interface UseImageGenerationReturn {
+    generate: (prompt: string, options?: {
+        model?: string
+        negativePrompt?: string
+        size?: string
+        quality?: 'standard' | 'hd'
+        style?: 'natural' | 'vivid'
+        n?: number
+        seed?: number
+    }) => Promise<string>
+    images: GeneratedImage[]
+    isGenerating: boolean
+    error: string | null
+    clearImages: () => void
+    clearError: () => void
+}
+
+export function useImageGeneration(options: UseImageGenerationOptions): UseImageGenerationReturn {
+    const [images, setImages] = useState<GeneratedImage[]>([])
+    const [isGenerating, setIsGenerating] = useState(false)
+    const [error, setError] = useState<string | null>(null)
+    const action = useAction(options.generateImageAction)
+
+    const generate = useCallback(async (prompt: string, opts?: {
+        model?: string; negativePrompt?: string; size?: string
+        quality?: 'standard' | 'hd'; style?: 'natural' | 'vivid'; n?: number; seed?: number
+    }) => {
+        setIsGenerating(true)
+        setError(null)
+        try {
+            const model = opts?.model ?? options.defaultModel ?? 'dall-e-3'
+            const result = await action({
+                prompt, model,
+                negativePrompt: opts?.negativePrompt,
+                size: opts?.size ?? '1024x1024',
+                quality: opts?.quality,
+                style: opts?.style,
+                n: opts?.n ?? 1,
+                seed: opts?.seed,
+            })
+            const img: GeneratedImage = {
+                url: result.startsWith('http') ? result : `data:image/png;base64,${result}`,
+                prompt, model, timestamp: Date.now(),
+            }
+            setImages(prev => [img, ...prev])
+            return img.url
+        } catch (err) {
+            const msg = err instanceof Error ? err.message : 'Image generation failed'
+            setError(msg)
+            throw err
+        } finally {
+            setIsGenerating(false)
+        }
+    }, [action, options.defaultModel])
+
+    return {
+        generate, images, isGenerating, error,
+        clearImages: () => setImages([]),
+        clearError: () => setError(null),
+    }
+}