@geenius/ai 0.1.0

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

@@ -0,0 +1,127 @@
+// @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

@@ -0,0 +1,89 @@
+// @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

@@ -0,0 +1,83 @@
+// @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

@@ -0,0 +1,56 @@
+// @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

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

@@ -0,0 +1,8 @@
+// @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

@@ -0,0 +1,27 @@
+{
+    "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

@@ -0,0 +1,21 @@
+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/README.md

@@ -0,0 +1 @@
+# ✦ @geenius-ai/solidjs-css\n\n> Geenius AI — SolidJS primitives and components (vanilla CSS variant)\n\n---\n\n## Overview\nBuilt with Steve Jobs-level minimalism and Jony Ive-level craftsmanship, this package is designed to deliver unparalleled developer experience (DX) and rock-solid performance.\n\n## Installation\n\n```bash\npnpm add @geenius-ai/solidjs-css\n```\n\n## Usage\n\n```typescript\nimport { init } from '@geenius-ai/solidjs-css';\n\n// Initialize the module with absolute precision\ninit({\n  mode: 'premium',\n});\n```\n\n## Architecture\n- **Zero-config**: It just works.\n- **Strictly Typed**: Fully written in TypeScript for flawless IntelliSense.\n- **Framework Agnostic**: seamlessly integrates into the Geenius ecosystem.\n\n---\n\n*Designed by Antigravity HQ*\n

package/packages/solidjs-css/package.json

@@ -0,0 +1,44 @@
+{
+  "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"
+  }
+}