@geenius/adapters 0.1.0

package/packages/convex/src/index.ts

@@ -0,0 +1,19 @@
+// @geenius-adapters/convex — Barrel
+
+export { default as schema } from './schema'
+
+export {
+  registerAdapter,
+  updateAdapterStatus,
+  updateAdapter,
+  removeAdapter,
+} from './mutations'
+
+export {
+  listAdapters,
+  listAdaptersByDomain,
+  getAdapter,
+  getActiveAdapter,
+  getAdapterStatusSummary,
+  getAdapterHealthLogs,
+} from './queries'

package/packages/convex/src/mutations.ts

@@ -0,0 +1,142 @@
+// @geenius-adapters/convex — Mutations
+
+import { mutation } from './_generated/server'
+import { v } from 'convex/values'
+
+const domainValidator = v.union(
+  v.literal('db'), v.literal('auth'), v.literal('payments'),
+  v.literal('ai'), v.literal('storage'), v.literal('admin'),
+)
+
+const statusValidator = v.union(
+  v.literal('connected'), v.literal('disconnected'),
+  v.literal('error'), v.literal('initializing'),
+)
+
+/**
+ * Register or update an adapter for a given domain.
+ */
+export const registerAdapter = mutation({
+  args: {
+    domain: domainValidator,
+    provider: v.string(),
+    config: v.object({
+      provider: v.string(),
+      apiKey: v.optional(v.string()),
+      baseUrl: v.optional(v.string()),
+      options: v.optional(v.any()),
+    }),
+    createdBy: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    // Check if adapter already exists for this domain
+    const existing = await ctx.db
+      .query('adapter_registry')
+      .withIndex('by_domain_provider', (q) => q.eq('domain', args.domain).eq('provider', args.provider))
+      .first()
+
+    const now = Date.now()
+
+    if (existing) {
+      await ctx.db.patch(existing._id, {
+        config: args.config,
+        status: 'initializing',
+        updatedAt: now,
+      })
+      return existing._id
+    }
+
+    return await ctx.db.insert('adapter_registry', {
+      domain: args.domain,
+      provider: args.provider,
+      status: 'initializing',
+      config: args.config,
+      connectedAt: undefined,
+      lastHealthCheck: undefined,
+      errorMessage: undefined,
+      createdBy: args.createdBy,
+      createdAt: now,
+      updatedAt: now,
+    })
+  },
+})
+
+/**
+ * Update an adapter's status.
+ */
+export const updateAdapterStatus = mutation({
+  args: {
+    adapterId: v.id('adapter_registry'),
+    status: statusValidator,
+    latency: v.optional(v.number()),
+    errorMessage: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const now = Date.now()
+    const update: Record<string, unknown> = {
+      status: args.status,
+      lastHealthCheck: now,
+      updatedAt: now,
+    }
+
+    if (args.status === 'connected') {
+      update.connectedAt = now
+      update.errorMessage = undefined
+    }
+    if (args.status === 'error' && args.errorMessage) {
+      update.errorMessage = args.errorMessage
+    }
+
+    await ctx.db.patch(args.adapterId, update)
+
+    // Log health check
+    await ctx.db.insert('adapter_health_logs', {
+      adapterId: args.adapterId,
+      domain: (await ctx.db.get(args.adapterId))!.domain,
+      status: args.status,
+      latency: args.latency,
+      errorMessage: args.errorMessage,
+      timestamp: now,
+    })
+  },
+})
+
+/**
+ * Update adapter configuration.
+ */
+export const updateAdapter = mutation({
+  args: {
+    adapterId: v.id('adapter_registry'),
+    config: v.object({
+      provider: v.string(),
+      apiKey: v.optional(v.string()),
+      baseUrl: v.optional(v.string()),
+      options: v.optional(v.any()),
+    }),
+  },
+  handler: async (ctx, args) => {
+    await ctx.db.patch(args.adapterId, {
+      config: args.config,
+      status: 'initializing',
+      updatedAt: Date.now(),
+    })
+  },
+})
+
+/**
+ * Remove an adapter from the registry.
+ */
+export const removeAdapter = mutation({
+  args: { adapterId: v.id('adapter_registry') },
+  handler: async (ctx, args) => {
+    // Remove health logs
+    const logs = await ctx.db
+      .query('adapter_health_logs')
+      .withIndex('by_adapter', (q) => q.eq('adapterId', args.adapterId))
+      .collect()
+    for (const log of logs) {
+      await ctx.db.delete(log._id)
+    }
+    await ctx.db.delete(args.adapterId)
+  },
+})

package/packages/convex/src/queries.ts

@@ -0,0 +1,106 @@
+// @geenius-adapters/convex — Queries
+
+import { query } from './_generated/server'
+import { v } from 'convex/values'
+
+/**
+ * List all registered adapters.
+ */
+export const listAdapters = query({
+  args: {},
+  handler: async (ctx) => {
+    return await ctx.db.query('adapter_registry').collect()
+  },
+})
+
+/**
+ * List adapters by domain.
+ */
+export const listAdaptersByDomain = query({
+  args: {
+    domain: v.union(
+      v.literal('db'), v.literal('auth'), v.literal('payments'),
+      v.literal('ai'), v.literal('storage'), v.literal('admin'),
+    ),
+  },
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query('adapter_registry')
+      .withIndex('by_domain', (q) => q.eq('domain', args.domain))
+      .collect()
+  },
+})
+
+/**
+ * Get a single adapter by ID.
+ */
+export const getAdapter = query({
+  args: { adapterId: v.id('adapter_registry') },
+  handler: async (ctx, args) => {
+    return await ctx.db.get(args.adapterId)
+  },
+})
+
+/**
+ * Get the active adapter for a specific domain.
+ * Returns the first connected adapter, or the first adapter if none connected.
+ */
+export const getActiveAdapter = query({
+  args: {
+    domain: v.union(
+      v.literal('db'), v.literal('auth'), v.literal('payments'),
+      v.literal('ai'), v.literal('storage'), v.literal('admin'),
+    ),
+  },
+  handler: async (ctx, args) => {
+    const adapters = await ctx.db
+      .query('adapter_registry')
+      .withIndex('by_domain', (q) => q.eq('domain', args.domain))
+      .collect()
+
+    return adapters.find((a) => a.status === 'connected') ?? adapters[0] ?? null
+  },
+})
+
+/**
+ * Get adapter status summary — one entry per domain.
+ */
+export const getAdapterStatusSummary = query({
+  args: {},
+  handler: async (ctx) => {
+    const all = await ctx.db.query('adapter_registry').collect()
+    const domains = ['db', 'auth', 'payments', 'ai', 'storage', 'admin'] as const
+
+    return domains.map((domain) => {
+      const domainAdapters = all.filter((a) => a.domain === domain)
+      const connected = domainAdapters.find((a) => a.status === 'connected')
+      return {
+        domain,
+        provider: connected?.provider ?? domainAdapters[0]?.provider ?? null,
+        status: connected?.status ?? domainAdapters[0]?.status ?? 'disconnected',
+        count: domainAdapters.length,
+      }
+    })
+  },
+})
+
+/**
+ * Get health logs for a specific adapter.
+ */
+export const getAdapterHealthLogs = query({
+  args: {
+    adapterId: v.id('adapter_registry'),
+    limit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const q = ctx.db
+      .query('adapter_health_logs')
+      .withIndex('by_adapter', (q) => q.eq('adapterId', args.adapterId))
+      .order('desc')
+
+    if (args.limit) {
+      return await q.take(args.limit)
+    }
+    return await q.take(50)
+  },
+})

package/packages/convex/src/schema.ts

@@ -0,0 +1,54 @@
+// @geenius-adapters/convex — Schema
+
+import { defineSchema, defineTable } from 'convex/server'
+import { v } from 'convex/values'
+
+export default defineSchema({
+  // ─── Adapter Registry ──────────────────────────────────────
+  adapter_registry: defineTable({
+    domain: v.union(
+      v.literal('db'), v.literal('auth'), v.literal('payments'),
+      v.literal('ai'), v.literal('storage'), v.literal('admin'),
+    ),
+    provider: v.string(),
+    status: v.union(
+      v.literal('connected'), v.literal('disconnected'),
+      v.literal('error'), v.literal('initializing'),
+    ),
+    config: v.object({
+      provider: v.string(),
+      apiKey: v.optional(v.string()),
+      baseUrl: v.optional(v.string()),
+      options: v.optional(v.any()),
+    }),
+    connectedAt: v.optional(v.number()),
+    lastHealthCheck: v.optional(v.number()),
+    errorMessage: v.optional(v.string()),
+    // Metadata
+    createdBy: v.optional(v.string()),
+    createdAt: v.number(),
+    updatedAt: v.number(),
+  })
+    .index('by_domain', ['domain'])
+    .index('by_status', ['status'])
+    .index('by_domain_provider', ['domain', 'provider']),
+
+  // ─── Adapter Health Logs ───────────────────────────────────
+  adapter_health_logs: defineTable({
+    adapterId: v.id('adapter_registry'),
+    domain: v.union(
+      v.literal('db'), v.literal('auth'), v.literal('payments'),
+      v.literal('ai'), v.literal('storage'), v.literal('admin'),
+    ),
+    status: v.union(
+      v.literal('connected'), v.literal('disconnected'),
+      v.literal('error'), v.literal('initializing'),
+    ),
+    latency: v.optional(v.number()),
+    errorMessage: v.optional(v.string()),
+    timestamp: v.number(),
+  })
+    .index('by_adapter', ['adapterId'])
+    .index('by_domain', ['domain'])
+    .index('by_timestamp', ['timestamp']),
+})

package/packages/convex/src/types.ts

@@ -0,0 +1,20 @@
+/**
+ * Configuration for Convex adapter
+ */
+export interface ConvexAdapterConfig {
+  deploymentUrl?: string
+  apiKey?: string
+}
+
+/**
+ * Interface for Convex database adapter
+ */
+export interface ConvexDbAdapter {
+  query: (queryFn: string, args?: Record<string, unknown>) => Promise<unknown>
+  mutation: (
+    mutationFn: string,
+    args?: Record<string, unknown>,
+  ) => Promise<unknown>
+  isReady: () => boolean
+  disconnect: () => Promise<void>
+}

package/packages/convex/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src"]
+}

package/packages/convex/tsup.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['cjs', 'esm'],
+  dts: true,
+  clean: true,
+  sourcemap: true,
+  external: ['convex'],
+})

package/packages/react/README.md

@@ -0,0 +1 @@
+# ✦ @geenius-adapters/react\n\n> Geenius Adapters — React hooks and providers\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-adapters/react\n```\n\n## Usage\n\n```typescript\nimport { init } from '@geenius-adapters/react';\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/react/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@geenius-adapters/react",
+  "version": "0.1.0",
+  "description": "Geenius Adapters — React hooks and providers",
+  "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"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "lint": "tsc --noEmit",
+    "test": "vitest run",
+    "clean": "rm -rf dist"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0"
+  },
+  "dependencies": {
+    "@geenius-adapters/shared": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/react": "^19.0.0",
+    "react": "^19.2.4",
+    "tsup": "^8.5.1",
+    "typescript": "~6.0.2",
+    "vitest": "^4.1.0"
+  },
+  "author": "Antigravity HQ",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

package/packages/react/src/components/AdapterCard.tsx

@@ -0,0 +1,49 @@
+// @geenius-adapters/react — AdapterCard
+
+import type { AdapterDomain, AdapterStatusInfo } from '@geenius-adapters/shared'
+import { DOMAIN_LABELS, DOMAIN_ICONS, DOMAIN_DESCRIPTIONS } from '@geenius-adapters/shared'
+import { AdapterStatusBadge } from './AdapterStatusBadge'
+
+export interface AdapterCardProps {
+  domain: AdapterDomain
+  status: AdapterStatusInfo
+  onClick?: () => void
+  className?: string
+}
+
+export function AdapterCard({ domain, status, onClick, className = '' }: AdapterCardProps) {
+  const label = DOMAIN_LABELS[domain]
+  const icon = DOMAIN_ICONS[domain]
+  const desc = DOMAIN_DESCRIPTIONS[domain]
+
+  return (
+    <button
+      type="button"
+      onClick={onClick}
+      className={`group flex w-full items-start gap-4 rounded-2xl border border-white/10 bg-white/[0.03] p-5 text-left backdrop-blur-sm transition-all hover:border-white/15 hover:bg-white/[0.05] ${className}`}
+      aria-label={`${label} adapter — ${status.status}`}
+    >
+      <div className="flex h-12 w-12 flex-shrink-0 items-center justify-center rounded-xl bg-white/5 text-2xl transition-transform group-hover:scale-105">
+        {icon}
+      </div>
+      <div className="min-w-0 flex-1">
+        <div className="flex items-center justify-between gap-2">
+          <h3 className="truncate text-sm font-bold text-white/90">{label}</h3>
+          <AdapterStatusBadge status={status.status} />
+        </div>
+        <p className="mt-0.5 text-xs text-white/40 line-clamp-2">{desc}</p>
+        {status.provider && status.provider !== 'none' && (
+          <div className="mt-2 flex items-center gap-2">
+            <span className="rounded-md bg-white/5 px-2 py-0.5 text-[0.625rem] font-semibold text-white/50">{status.provider}</span>
+            {status.latency && (
+              <span className="text-[0.625rem] text-white/30">{status.latency}ms</span>
+            )}
+          </div>
+        )}
+        {status.error && (
+          <p className="mt-1.5 truncate text-[0.625rem] text-red-400/80">{status.error}</p>
+        )}
+      </div>
+    </button>
+  )
+}

package/packages/react/src/components/AdapterConfigForm.tsx

@@ -0,0 +1,118 @@
+// @geenius-adapters/react — AdapterConfigForm
+
+import { useState } from 'react'
+import type { AdapterDomain, DomainAdapterConfig } from '@geenius-adapters/shared'
+import { DOMAIN_LABELS, getProvidersForDomain } from '@geenius-adapters/shared'
+
+export interface AdapterConfigFormProps {
+  domain: AdapterDomain
+  initialConfig?: DomainAdapterConfig
+  onSave: (config: DomainAdapterConfig) => Promise<void> | void
+  onCancel?: () => void
+  className?: string
+}
+
+export function AdapterConfigForm({ domain, initialConfig, onSave, onCancel, className = '' }: AdapterConfigFormProps) {
+  const providers = getProvidersForDomain(domain)
+  const [provider, setProvider] = useState(initialConfig?.provider ?? providers[0]?.id ?? '')
+  const [apiKey, setApiKey] = useState(initialConfig?.apiKey ?? '')
+  const [baseUrl, setBaseUrl] = useState(initialConfig?.baseUrl ?? '')
+  const [isSaving, setIsSaving] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+
+  const selectedMeta = providers.find((p) => p.id === provider)
+  const needsApiKey = !['localStorage', 'noop'].includes(provider)
+  const needsBaseUrl = ['ollama', 'minio', 'neon', 'supabase'].includes(provider)
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault()
+    setError(null)
+    if (!provider) { setError('Select a provider'); return }
+    if (needsApiKey && !apiKey.trim()) { setError('API key is required'); return }
+    setIsSaving(true)
+    try {
+      await onSave({ provider, apiKey: apiKey || undefined, baseUrl: baseUrl || undefined })
+    } catch (e) {
+      setError(e instanceof Error ? e.message : 'Failed to save')
+    } finally {
+      setIsSaving(false)
+    }
+  }
+
+  return (
+    <form onSubmit={handleSubmit} className={`space-y-5 rounded-2xl border border-white/10 bg-white/[0.03] p-6 backdrop-blur-sm ${className}`} noValidate>
+      <div>
+        <h3 className="text-lg font-bold text-white/90">Configure {DOMAIN_LABELS[domain]}</h3>
+        <p className="mt-1 text-xs text-white/40">Select and configure your preferred provider.</p>
+      </div>
+
+      {error && <div className="rounded-lg border border-red-500/20 bg-red-500/10 px-4 py-3 text-sm text-red-400" role="alert">{error}</div>}
+
+      <div>
+        <label htmlFor={`adapter-${domain}-provider`} className="mb-1.5 block text-xs font-semibold uppercase tracking-wider text-white/40">Provider</label>
+        <div className="grid gap-2 sm:grid-cols-2">
+          {providers.map((p) => (
+            <button
+              key={p.id}
+              type="button"
+              onClick={() => setProvider(p.id)}
+              className={`flex flex-col rounded-xl border p-3 text-left transition-all ${
+                provider === p.id
+                  ? 'border-indigo-500/30 bg-indigo-500/10'
+                  : 'border-white/10 bg-white/[0.02] hover:bg-white/[0.04]'
+              }`}
+            >
+              <span className="text-xs font-semibold text-white/80">{p.name}</span>
+              <span className="mt-0.5 text-[0.625rem] text-white/40">{p.description}</span>
+              <span className={`mt-1 self-start rounded px-1.5 py-0.5 text-[0.5625rem] font-bold uppercase ${
+                p.tier === 'pronto' ? 'bg-emerald-500/10 text-emerald-400' : p.tier === 'mvp' ? 'bg-blue-500/10 text-blue-400' : 'bg-purple-500/10 text-purple-400'
+              }`}>{p.tier}</span>
+            </button>
+          ))}
+        </div>
+      </div>
+
+      {needsApiKey && (
+        <div>
+          <label htmlFor={`adapter-${domain}-apiKey`} className="mb-1.5 block text-xs font-semibold uppercase tracking-wider text-white/40">API Key</label>
+          <input
+            id={`adapter-${domain}-apiKey`}
+            type="password"
+            value={apiKey}
+            onChange={(e) => setApiKey(e.target.value)}
+            placeholder={`Enter ${selectedMeta?.name ?? provider} API key`}
+            autoComplete="off"
+            className="w-full rounded-xl border border-white/10 bg-white/[0.02] px-4 py-3 text-sm text-white/90 placeholder:text-white/20 focus:border-indigo-500/50 focus:outline-none focus:ring-2 focus:ring-indigo-500/20"
+          />
+        </div>
+      )}
+
+      {needsBaseUrl && (
+        <div>
+          <label htmlFor={`adapter-${domain}-url`} className="mb-1.5 block text-xs font-semibold uppercase tracking-wider text-white/40">Base URL</label>
+          <input
+            id={`adapter-${domain}-url`}
+            type="url"
+            value={baseUrl}
+            onChange={(e) => setBaseUrl(e.target.value)}
+            placeholder={`https://...`}
+            className="w-full rounded-xl border border-white/10 bg-white/[0.02] px-4 py-3 text-sm text-white/90 placeholder:text-white/20 focus:border-indigo-500/50 focus:outline-none focus:ring-2 focus:ring-indigo-500/20"
+          />
+        </div>
+      )}
+
+      <div className="flex items-center justify-end gap-3 pt-2">
+        {onCancel && (
+          <button type="button" onClick={onCancel} className="rounded-xl px-5 py-2.5 text-sm font-semibold text-white/50 hover:text-white/70">Cancel</button>
+        )}
+        <button
+          type="submit"
+          disabled={isSaving || !provider}
+          className="flex items-center gap-2 rounded-xl bg-indigo-500 px-6 py-2.5 text-sm font-semibold text-white hover:bg-indigo-400 disabled:opacity-50"
+        >
+          {isSaving ? 'Saving…' : 'Save Configuration'}
+        </button>
+      </div>
+    </form>
+  )
+}

package/packages/react/src/components/AdapterList.tsx

@@ -0,0 +1,84 @@
+// @geenius-adapters/react — AdapterList
+
+import { useState, useMemo } from 'react'
+import { useAdapters } from '../hooks'
+import { AdapterCard } from './AdapterCard'
+import { ADAPTER_DOMAINS, DOMAIN_LABELS } from '@geenius-adapters/shared'
+import type { AdapterDomain, AdapterStatusType } from '@geenius-adapters/shared'
+
+export interface AdapterListProps {
+  onSelect?: (domain: AdapterDomain) => void
+  filterStatus?: AdapterStatusType
+  className?: string
+}
+
+export function AdapterList({ onSelect, filterStatus, className = '' }: AdapterListProps) {
+  const { statuses, isLoading } = useAdapters()
+  const [search, setSearch] = useState('')
+
+  const filteredDomains = useMemo(() => {
+    let domains = [...ADAPTER_DOMAINS]
+    if (search) {
+      const q = search.toLowerCase()
+      domains = domains.filter((d) => {
+        const label = DOMAIN_LABELS[d].toLowerCase()
+        const provider = statuses[d]?.provider?.toLowerCase() ?? ''
+        return label.includes(q) || provider.includes(q) || d.includes(q)
+      })
+    }
+    if (filterStatus) {
+      domains = domains.filter((d) => statuses[d]?.status === filterStatus)
+    }
+    return domains
+  }, [search, filterStatus, statuses])
+
+  if (isLoading) {
+    return (
+      <div className={`space-y-3 ${className}`} role="status" aria-label="Loading adapters">
+        {[1, 2, 3, 4].map((i) => (
+          <div key={i} className="animate-pulse rounded-2xl border border-white/5 bg-white/[0.02] p-5">
+            <div className="flex items-start gap-4">
+              <div className="h-12 w-12 rounded-xl bg-white/10" />
+              <div className="flex-1 space-y-2">
+                <div className="h-3 w-24 rounded bg-white/10" />
+                <div className="h-2 w-48 rounded bg-white/5" />
+              </div>
+            </div>
+          </div>
+        ))}
+      </div>
+    )
+  }
+
+  return (
+    <div className={className}>
+      <div className="mb-4">
+        <input
+          type="text"
+          value={search}
+          onChange={(e) => setSearch(e.target.value)}
+          placeholder="Search adapters..."
+          aria-label="Search adapters"
+          className="w-full rounded-xl border border-white/10 bg-white/[0.02] px-4 py-2.5 text-sm text-white/90 placeholder:text-white/20 focus:border-indigo-500/50 focus:outline-none focus:ring-2 focus:ring-indigo-500/20"
+        />
+      </div>
+
+      {filteredDomains.length === 0 ? (
+        <div className="rounded-xl border border-white/5 bg-white/[0.01] p-8 text-center">
+          <p className="text-sm text-white/40">{search ? 'No adapters match your search' : 'No adapters configured'}</p>
+        </div>
+      ) : (
+        <div className="grid gap-3 sm:grid-cols-2" role="list" aria-label="Adapter list">
+          {filteredDomains.map((domain) => (
+            <AdapterCard
+              key={domain}
+              domain={domain}
+              status={statuses[domain]}
+              onClick={() => onSelect?.(domain)}
+            />
+          ))}
+        </div>
+      )}
+    </div>
+  )
+}