@geenius/ai 0.1.0 → 0.3.1

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

@@ -1,127 +0,0 @@
-// @geenius-ai/solidjs — src/primitives/createMemory.ts
-
-import { createSignal } from 'solid-js'
-import type {
-    MemoryEntry,
-    MemoryQuery,
-    MemoryNamespace,
-    MemoryImportance,
-    MemoryType,
-} from '@geenius-ai/shared'
-
-export interface CreateMemoryOptions {
-    storeFn: (entry: Omit<MemoryEntry, 'id' | 'accessCount' | 'lastAccessedAt' | 'createdAt' | 'updatedAt'>) => Promise<MemoryEntry>
-    searchFn: (query: MemoryQuery) => Promise<MemoryEntry[]>
-    deleteFn: (id: string) => Promise<void>
-    clearFn: (namespace: MemoryNamespace, scopeId: string) => Promise<void>
-    defaultNamespace?: MemoryNamespace
-    defaultScopeId?: string
-}
-
-export function createMemory(options: CreateMemoryOptions) {
-    const {
-        storeFn, searchFn, deleteFn, clearFn,
-        defaultNamespace = 'user',
-        defaultScopeId = '',
-    } = options
-
-    const [memories, setMemories] = createSignal<MemoryEntry[]>([])
-    const [isLoading, setIsLoading] = createSignal(false)
-    const [error, setError] = createSignal<Error | null>(null)
-
-    const store = async (
-        key: string,
-        value: string,
-        opts?: {
-            namespace?: MemoryNamespace
-            type?: MemoryType
-            importance?: MemoryImportance
-            metadata?: Record<string, unknown>
-            scopeId?: string
-        },
-    ) => {
-        setIsLoading(true)
-        setError(null)
-        try {
-            const entry = await storeFn({
-                namespace: opts?.namespace ?? defaultNamespace,
-                type: opts?.type ?? 'fact',
-                importance: opts?.importance ?? 'medium',
-                key,
-                value,
-                metadata: opts?.metadata,
-                scopeId: opts?.scopeId ?? defaultScopeId,
-            })
-            setMemories(prev => [...prev, entry])
-            return entry
-        } catch (err) {
-            const e = err instanceof Error ? err : new Error(String(err))
-            setError(e)
-            throw e
-        } finally {
-            setIsLoading(false)
-        }
-    }
-
-    const recall = async (key: string, namespace?: MemoryNamespace) => {
-        setIsLoading(true)
-        setError(null)
-        try {
-            const results = await searchFn({
-                namespace: namespace ?? defaultNamespace,
-                key,
-                scopeId: defaultScopeId,
-                limit: 1,
-            })
-            return results.length > 0 ? results[0] : null
-        } catch (err) {
-            const e = err instanceof Error ? err : new Error(String(err))
-            setError(e)
-            throw e
-        } finally {
-            setIsLoading(false)
-        }
-    }
-
-    const search = async (query: MemoryQuery) => {
-        setIsLoading(true)
-        setError(null)
-        try {
-            const results = await searchFn({ scopeId: defaultScopeId, ...query })
-            setMemories(results)
-            return results
-        } catch (err) {
-            const e = err instanceof Error ? err : new Error(String(err))
-            setError(e)
-            throw e
-        } finally {
-            setIsLoading(false)
-        }
-    }
-
-    const remove = async (id: string) => {
-        setError(null)
-        try {
-            await deleteFn(id)
-            setMemories(prev => prev.filter(m => m.id !== id))
-        } catch (err) {
-            const e = err instanceof Error ? err : new Error(String(err))
-            setError(e)
-            throw e
-        }
-    }
-
-    const clear = async (namespace?: MemoryNamespace) => {
-        setError(null)
-        try {
-            await clearFn(namespace ?? defaultNamespace, defaultScopeId)
-            setMemories([])
-        } catch (err) {
-            const e = err instanceof Error ? err : new Error(String(err))
-            setError(e)
-            throw e
-        }
-    }
-
-    return { store, recall, search, remove, clear, memories, isLoading, error }
-}

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

@@ -1,89 +0,0 @@
-// @geenius-ai/solidjs — src/primitives/createModelTest.ts
-
-/**
- * Model test primitive — run tests on individual or batch models.
- */
-
-import { createSignal } from 'solid-js'
-import type { AIGenerationType } from '@geenius-ai/shared'
-
-export interface ModelTestResult {
-    model: string
-    type: AIGenerationType
-    result: string
-    durationMs: number
-    timestamp: number
-    error?: string
-}
-
-export interface CreateModelTestOptions {
-    callGenerateText?: (args: any) => Promise<string>
-    callGenerateImage?: (args: any) => Promise<string>
-    callGenerateAudio?: (args: any) => Promise<string>
-    callGenerateVideo?: (args: any) => Promise<string>
-}
-
-export interface CreateModelTestReturn {
-    runTest: (model: string, prompt: string, type?: AIGenerationType) => Promise<ModelTestResult>
-    runBatchTest: (models: string[], prompt: string) => Promise<ModelTestResult[]>
-    results: () => ModelTestResult[]
-    isRunning: () => boolean
-    clearResults: () => void
-}
-
-export function createModelTest(options: CreateModelTestOptions = {}): CreateModelTestReturn {
-    const [results, setResults] = createSignal<ModelTestResult[]>([])
-    const [isRunning, setIsRunning] = createSignal(false)
-
-    async function runTest(model: string, prompt: string, type: AIGenerationType = 'text'): Promise<ModelTestResult> {
-        setIsRunning(true)
-        const start = Date.now()
-
-        try {
-            let result = ''
-            switch (type) {
-                case 'text':
-                    if (!options.callGenerateText) throw new Error('callGenerateText not provided')
-                    result = await options.callGenerateText({ model, messages: [{ role: 'user', content: prompt }], caller: 'model-test' })
-                    break
-                case 'image':
-                    if (!options.callGenerateImage) throw new Error('callGenerateImage not provided')
-                    result = await options.callGenerateImage({ prompt, model })
-                    break
-                case 'audio':
-                    if (!options.callGenerateAudio) throw new Error('callGenerateAudio not provided')
-                    result = await options.callGenerateAudio({ prompt })
-                    break
-                case 'video':
-                    if (!options.callGenerateVideo) throw new Error('callGenerateVideo not provided')
-                    result = await options.callGenerateVideo({ prompt })
-                    break
-                default:
-                    throw new Error(`Unsupported test type: ${type}`)
-            }
-
-            const testResult: ModelTestResult = { model, type, result, durationMs: Date.now() - start, timestamp: Date.now() }
-            setResults(prev => [...prev, testResult])
-            return testResult
-        } catch (err) {
-            const testResult: ModelTestResult = { model, type, result: '', durationMs: Date.now() - start, timestamp: Date.now(), error: err instanceof Error ? err.message : 'Test failed' }
-            setResults(prev => [...prev, testResult])
-            return testResult
-        } finally {
-            setIsRunning(false)
-        }
-    }
-
-    async function runBatchTest(models: string[], prompt: string): Promise<ModelTestResult[]> {
-        setIsRunning(true)
-        const batch: ModelTestResult[] = []
-        for (const model of models) {
-            const r = await runTest(model, prompt)
-            batch.push(r)
-        }
-        setIsRunning(false)
-        return batch
-    }
-
-    return { runTest, runBatchTest, results, isRunning, clearResults: () => setResults([]) }
-}

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

@@ -1,83 +0,0 @@
-// @geenius-ai/solidjs — src/primitives/createSkills.ts
-
-import { createSignal, createMemo } from 'solid-js'
-import type {
-    SkillDefinition,
-    SkillContext,
-    SkillResult,
-    SkillCategory,
-} from '@geenius-ai/shared'
-import { BUILT_IN_SKILLS } from '@geenius-ai/shared'
-
-export interface CreateSkillsOptions {
-    executeFn: (context: SkillContext) => Promise<SkillResult>
-    customSkills?: SkillDefinition[]
-    defaultModel?: string
-    userId?: string
-}
-
-export function createSkills(options: CreateSkillsOptions) {
-    const { executeFn, customSkills = [], defaultModel, userId } = options
-    const [result, setResult] = createSignal<SkillResult | null>(null)
-    const [isExecuting, setIsExecuting] = createSignal(false)
-    const [error, setError] = createSignal<Error | null>(null)
-
-    const allSkills = createMemo(() => {
-        const map = new Map<string, SkillDefinition>()
-        for (const skill of Object.values(BUILT_IN_SKILLS)) map.set(skill.id, skill)
-        for (const skill of customSkills) map.set(skill.id, skill)
-        return Array.from(map.values())
-    })
-
-    const byCategory = (category: SkillCategory) =>
-        allSkills().filter(s => s.category === category)
-
-    const search = (query: string) => {
-        const q = query.toLowerCase()
-        return allSkills().filter(s =>
-            s.name.toLowerCase().includes(q) ||
-            s.description.toLowerCase().includes(q) ||
-            s.tags?.some(t => t.toLowerCase().includes(q))
-        )
-    }
-
-    const getSkill = (id: string) => allSkills().find(s => s.id === id)
-
-    const execute = async (
-        skillId: string,
-        params: Record<string, unknown>,
-        context?: Record<string, unknown>,
-    ) => {
-        setIsExecuting(true)
-        setError(null)
-        try {
-            const res = await executeFn({
-                skillId,
-                params,
-                userId,
-                context,
-                model: defaultModel,
-            })
-            setResult(res)
-            return res
-        } catch (err) {
-            const e = err instanceof Error ? err : new Error(String(err))
-            setError(e)
-            throw e
-        } finally {
-            setIsExecuting(false)
-        }
-    }
-
-    return {
-        skills: allSkills,
-        byCategory,
-        search,
-        getSkill,
-        execute,
-        result,
-        isExecuting,
-        error,
-        reset: () => { setResult(null); setError(null) },
-    }
-}

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

@@ -1,56 +0,0 @@
-// @geenius-ai/solidjs — src/primitives/createTextToSpeech.ts
-
-import { createSignal } from 'solid-js'
-
-export interface CreateTextToSpeechOptions {
-    callGenerateAudio: (args: any) => Promise<string>
-    defaultVoice?: string
-    defaultModel?: string
-    autoPlay?: boolean
-}
-
-export function createTextToSpeech(options: CreateTextToSpeechOptions) {
-    const [isGenerating, setIsGenerating] = createSignal(false)
-    const [isSpeaking, setIsSpeaking] = createSignal(false)
-    const [error, setError] = createSignal<string | null>(null)
-    const [audioUrl, setAudioUrl] = createSignal<string | null>(null)
-    let currentAudio: HTMLAudioElement | null = null
-
-    async function speak(text: string, opts?: { voice?: string; model?: string; speed?: number }) {
-        setIsGenerating(true)
-        setError(null)
-        try {
-            const base64 = await options.callGenerateAudio({
-                prompt: text,
-                voice: opts?.voice ?? options.defaultVoice ?? 'alloy',
-                model: opts?.model ?? options.defaultModel,
-                speed: opts?.speed,
-            })
-            const url = base64.startsWith('http') ? base64 : `data:audio/mp3;base64,${base64}`
-            setAudioUrl(url)
-
-            if (options.autoPlay !== false) {
-                stop()
-                const audio = new Audio(url)
-                currentAudio = audio
-                setIsSpeaking(true)
-                audio.onended = () => setIsSpeaking(false)
-                await audio.play()
-            }
-            return url
-        } catch (err) {
-            setError(err instanceof Error ? err.message : 'TTS failed')
-            throw err
-        } finally {
-            setIsGenerating(false)
-        }
-    }
-
-    function stop() {
-        currentAudio?.pause()
-        currentAudio = null
-        setIsSpeaking(false)
-    }
-
-    return { speak, stop, isGenerating, isSpeaking, error, audioUrl, clearError: () => setError(null) }
-}

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

@@ -1,46 +0,0 @@
-// @geenius-ai/solidjs — src/primitives/createVideoGeneration.ts
-
-import { createSignal } from 'solid-js'
-
-export interface GeneratedVideo {
-    url: string
-    prompt: string
-    model: string
-    timestamp: number
-}
-
-export interface CreateVideoGenerationOptions {
-    callGenerateVideo: (args: any) => Promise<string>
-    defaultModel?: string
-}
-
-export function createVideoGeneration(options: CreateVideoGenerationOptions) {
-    const [videos, setVideos] = createSignal<GeneratedVideo[]>([])
-    const [isGenerating, setIsGenerating] = createSignal(false)
-    const [error, setError] = createSignal<string | null>(null)
-
-    async function generate(prompt: string, opts?: {
-        model?: string; duration?: number; aspectRatio?: '16:9' | '9:16' | '1:1'
-        startImage?: string; endImage?: string
-    }) {
-        setIsGenerating(true)
-        setError(null)
-        try {
-            const model = opts?.model ?? options.defaultModel ?? 'minimax/video-01'
-            const result = await options.callGenerateVideo({ prompt, model, ...opts })
-            setVideos(prev => [{ url: result, prompt, model, timestamp: Date.now() }, ...prev])
-            return result
-        } catch (err) {
-            setError(err instanceof Error ? err.message : 'Video generation failed')
-            throw err
-        } finally {
-            setIsGenerating(false)
-        }
-    }
-
-    return {
-        generate, videos, isGenerating, error,
-        clearVideos: () => setVideos([]),
-        clearError: () => setError(null),
-    }
-}

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

@@ -1,8 +0,0 @@
-// @geenius-ai/solidjs — src/primitives/index.ts
-
-export { createAI, type CreateAIOptions, type CreateAIReturn } from './createAI'
-export { createChat, type CreateChatOptions, type CreateChatReturn } from './createChat'
-export { createModelTest, type CreateModelTestOptions, type CreateModelTestReturn, type ModelTestResult } from './createModelTest'
-export { createImageGeneration, type CreateImageGenerationOptions, type GeneratedImage } from './createImageGeneration'
-export { createTextToSpeech, type CreateTextToSpeechOptions } from './createTextToSpeech'
-export { createVideoGeneration, type CreateVideoGenerationOptions, type GeneratedVideo } from './createVideoGeneration'

package/packages/solidjs/tsconfig.json

@@ -1,27 +0,0 @@
-{
-    "compilerOptions": {
-        "target": "ES2022",
-        "module": "ESNext",
-        "moduleResolution": "bundler",
-        "declaration": true,
-        "declarationMap": true,
-        "sourceMap": true,
-        "outDir": "./dist",
-        "rootDir": "./src",
-        "strict": true,
-        "esModuleInterop": true,
-        "skipLibCheck": true,
-        "forceConsistentCasingInFileNames": true,
-        "resolveJsonModule": true,
-        "isolatedModules": true,
-        "jsx": "preserve",
-        "jsxImportSource": "solid-js"
-    },
-    "include": [
-        "src"
-    ],
-    "exclude": [
-        "node_modules",
-        "dist"
-    ]
-}

package/packages/solidjs/tsup.config.ts

@@ -1,21 +0,0 @@
-import { defineConfig } from 'tsup'
-
-export default defineConfig({
-    entry: {
-        index: 'src/index.ts',
-        'primitives/index': 'src/primitives/index.ts',
-        'components/index': 'src/components/index.ts',
-        'pages/index': 'src/pages/index.ts',
-    },
-    format: ['esm'],
-    dts: true,
-    clean: true,
-    sourcemap: true,
-    jsx: 'preserve',
-    external: [
-        'solid-js',
-        'convex',
-        'convex/react',
-        '@geenius-ai/shared',
-    ],
-})

package/packages/solidjs-css/package.json

@@ -1,44 +0,0 @@
-{
-  "name": "@geenius-ai/solidjs-css",
-  "version": "0.1.0",
-  "description": "Geenius AI — SolidJS primitives and components (vanilla CSS variant)",
-  "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    },
-    "./styles.css": "./dist/styles.css"
-  },
-  "scripts": {
-    "build": "tsup",
-    "lint": "tsc --noEmit",
-    "clean": "rm -rf dist"
-  },
-  "files": [
-    "dist"
-  ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "peerDependencies": {
-    "solid-js": ">=1.6.0"
-  },
-  "dependencies": {
-    "@geenius-ai/shared": "workspace:*"
-  },
-  "devDependencies": {
-    "solid-js": "^1.9.5",
-    "tsup": "^8.5.1",
-    "typescript": "~6.0.2"
-  },
-  "author": "Antigravity HQ",
-  "license": "MIT",
-  "engines": {
-    "node": ">=20.0.0"
-  }
-}