@geenius/adapters 0.1.0

package/packages/shared/src/ai/openai.ts

@@ -0,0 +1,120 @@
+// @geenius/adapters — OpenAI implementation (MVP tier)
+// Wraps the OpenAI API to conform to AiAdapter interface.
+// Requires: openai
+
+import type { ChatMessage, ChatResponse, AiOptions } from '../types'
+import type { AiAdapter } from './interface'
+
+interface OpenAIStreamChunk {
+  choices: Array<{ delta: { content?: string | null }; finish_reason: string | null }>
+}
+
+interface OpenAIClient {
+  chat: {
+    completions: {
+      create(params: {
+        model: string
+        messages: Array<{ role: string; content: string }>
+        temperature?: number
+        max_tokens?: number
+        stream?: false
+      }): Promise<{
+        choices: Array<{
+          message: { content: string | null }
+          finish_reason: string
+        }>
+        usage?: {
+          prompt_tokens: number
+          completion_tokens: number
+          total_tokens: number
+        }
+      }>
+      create(params: {
+        model: string
+        messages: Array<{ role: string; content: string }>
+        temperature?: number
+        max_tokens?: number
+        stream: true
+      }): Promise<AsyncIterable<OpenAIStreamChunk>>
+    }
+  }
+  embeddings: {
+    create: (params: {
+      model: string
+      input: string | string[]
+    }) => Promise<{
+      data: Array<{ embedding: number[] }>
+    }>
+  }
+}
+
+export interface OpenAiAdapterOptions {
+  /** Pre-configured OpenAI client instance */
+  client: OpenAIClient
+  /** Default model for chat/completions (default: gpt-4o-mini) */
+  defaultModel?: string
+  /** Default model for embeddings (default: text-embedding-3-small) */
+  embeddingModel?: string
+}
+
+export function createOpenAiAdapter(options: OpenAiAdapterOptions): AiAdapter {
+  const {
+    client,
+    defaultModel = 'gpt-4o-mini',
+    embeddingModel = 'text-embedding-3-small',
+  } = options
+
+  return {
+    async chat(messages: ChatMessage[], opts?: AiOptions): Promise<ChatResponse> {
+      const response = await client.chat.completions.create({
+        model: opts?.model || defaultModel,
+        messages: messages.map((m) => ({ role: m.role, content: m.content })),
+        temperature: opts?.temperature,
+        max_tokens: opts?.maxTokens,
+      })
+
+      const choice = response.choices[0]
+      return {
+        content: choice?.message?.content || '',
+        finishReason: (choice?.finish_reason === 'stop' ? 'stop'
+          : choice?.finish_reason === 'length' ? 'length'
+          : 'error') as ChatResponse['finishReason'],
+        usage: response.usage ? {
+          promptTokens: response.usage.prompt_tokens,
+          completionTokens: response.usage.completion_tokens,
+          totalTokens: response.usage.total_tokens,
+        } : undefined,
+      }
+    },
+
+    async complete(prompt: string, opts?: AiOptions): Promise<string> {
+      const response = await this.chat(
+        [{ role: 'user', content: prompt }],
+        opts,
+      )
+      return response.content
+    },
+
+    async embed(text: string | string[]): Promise<number[][]> {
+      const response = await client.embeddings.create({
+        model: embeddingModel,
+        input: text,
+      })
+      return response.data.map((d) => d.embedding)
+    },
+
+    async *stream(messages: ChatMessage[], opts?: AiOptions): AsyncIterable<string> {
+      const iterable = await client.chat.completions.create({
+        model: opts?.model || defaultModel,
+        messages: messages.map((m) => ({ role: m.role, content: m.content })),
+        temperature: opts?.temperature,
+        max_tokens: opts?.maxTokens,
+        stream: true,
+      })
+      for await (const chunk of iterable) {
+        const delta = chunk.choices[0]?.delta?.content
+        if (delta) yield delta
+      }
+    },
+  }
+}

package/packages/shared/src/ai/vercel-ai.ts

@@ -0,0 +1,101 @@
+// @geenius/adapters — Vercel AI SDK adapter
+// Wraps the Vercel AI SDK's generateText / embed to conform to AiAdapter.
+// Requires: ai (Vercel AI SDK)
+
+import type { ChatMessage, ChatResponse, AiOptions } from '../types'
+import type { AiAdapter } from './interface'
+
+export interface VercelAiAdapterOptions {
+  /** Vercel AI SDK model instance (e.g. openai('gpt-4o'), anthropic('claude-sonnet-4-20250514')) */
+  model: any
+  /** Optional embedding model instance */
+  embeddingModel?: any
+}
+
+export function createVercelAiAdapter(options: VercelAiAdapterOptions): AiAdapter {
+  const { model, embeddingModel } = options
+
+  return {
+    async chat(messages: ChatMessage[], opts?: AiOptions): Promise<ChatResponse> {
+      const { generateText } = await import('ai')
+
+      // Build messages in Vercel AI SDK format
+      const sdkMessages = messages.map((m) => ({
+        role: m.role as 'system' | 'user' | 'assistant',
+        content: m.content,
+      }))
+
+      const result = await generateText({
+        model: opts?.model ? model : model, // Use provided model instance
+        messages: sdkMessages,
+        temperature: opts?.temperature,
+        maxTokens: opts?.maxTokens,
+      })
+
+      return {
+        content: result.text || '',
+        finishReason: (result.finishReason === 'stop' ? 'stop'
+          : result.finishReason === 'length' ? 'length'
+          : 'error') as ChatResponse['finishReason'],
+        usage: result.usage ? {
+          promptTokens: result.usage.promptTokens || 0,
+          completionTokens: result.usage.completionTokens || 0,
+          totalTokens: (result.usage.promptTokens || 0) + (result.usage.completionTokens || 0),
+        } : undefined,
+      }
+    },
+
+    async complete(prompt: string, opts?: AiOptions): Promise<string> {
+      const { generateText } = await import('ai')
+
+      const result = await generateText({
+        model,
+        prompt,
+        temperature: opts?.temperature,
+        maxTokens: opts?.maxTokens,
+      })
+
+      return result.text || ''
+    },
+
+    async embed(text: string | string[]): Promise<number[][]> {
+      if (!embeddingModel) {
+        throw new Error(
+          'Vercel AI SDK adapter requires an embeddingModel option for embeddings. ' +
+          'Pass it when creating the adapter: createVercelAiAdapter({ model, embeddingModel })',
+        )
+      }
+
+      const { embed, embedMany } = await import('ai')
+      const inputs = Array.isArray(text) ? text : [text]
+
+      if (inputs.length === 1) {
+        const result = await embed({ model: embeddingModel, value: inputs[0] })
+        return [result.embedding]
+      }
+
+      const result = await embedMany({ model: embeddingModel, values: inputs })
+      return result.embeddings
+    },
+
+    async *stream(messages: ChatMessage[], opts?: AiOptions): AsyncIterable<string> {
+      const { streamText } = await import('ai')
+
+      const sdkMessages = messages.map((m) => ({
+        role: m.role as 'system' | 'user' | 'assistant',
+        content: m.content,
+      }))
+
+      const result = await streamText({
+        model,
+        messages: sdkMessages,
+        temperature: opts?.temperature,
+        maxTokens: opts?.maxTokens,
+      })
+
+      for await (const delta of result.textStream) {
+        yield delta
+      }
+    },
+  }
+}

package/packages/shared/src/auth/better-auth.ts

@@ -0,0 +1,118 @@
+// @geenius/adapters — Better Auth implementation (Lancio tier)
+// Wraps the Better Auth client SDK to conform to AuthAdapter interface.
+// Requires: better-auth, @convex-dev/better-auth
+
+import type { AuthUser, AuthSession } from '../types'
+import type { AuthAdapter, OAuthProvider } from './interface'
+
+interface BetterAuthClient {
+  signIn: {
+    email: (params: { email: string; password: string }) => Promise<{ data?: { session?: { token: string }; user?: { id: string; email: string; name: string; image?: string } }; error?: { message: string } }>
+    social: (params: { provider: string; callbackURL?: string }) => Promise<{ data?: { url?: string; redirect?: boolean }; error?: { message: string } }>
+  }
+  signUp: {
+    email: (params: { email: string; password: string; name: string }) => Promise<{ data?: { session?: { token: string }; user?: { id: string; email: string; name: string; image?: string } }; error?: { message: string } }>
+  }
+  signOut: () => Promise<void>
+  getSession: () => Promise<{ data?: { session?: { token: string; expiresAt: string; userId: string }; user?: { id: string; email: string; name: string; image?: string } } }>
+  updateUser: (params: { name?: string; image?: string }) => Promise<{ data?: { id: string; email: string; name: string; image?: string }; error?: { message: string } }>
+}
+
+export interface BetterAuthAdapterOptions {
+  /** Pre-configured Better Auth client instance */
+  client: BetterAuthClient
+}
+
+export function createBetterAuthAdapter(options: BetterAuthAdapterOptions): AuthAdapter {
+  const { client } = options
+
+  return {
+    async signInWithOAuth(provider: OAuthProvider, options?: { redirectUrl?: string }): Promise<{ url: string }> {
+      const result = await client.signIn.social({
+        provider,
+        callbackURL: options?.redirectUrl,
+      })
+      if (result.error) throw new Error(result.error.message)
+      const url = result.data?.url ?? options?.redirectUrl ?? '/'
+      return { url }
+    },
+
+    async signIn(email: string, password: string): Promise<AuthSession> {
+      const result = await client.signIn.email({ email, password })
+      if (result.error) throw new Error(result.error.message)
+      if (!result.data?.session || !result.data?.user) throw new Error('Sign in failed')
+
+      return {
+        userId: result.data.user.id,
+        token: result.data.session.token,
+      }
+    },
+
+    async signUp(email: string, password: string, name?: string): Promise<AuthSession> {
+      const result = await client.signUp.email({
+        email,
+        password,
+        name: name || email.split('@')[0],
+      })
+      if (result.error) throw new Error(result.error.message)
+      if (!result.data?.session || !result.data?.user) throw new Error('Sign up failed')
+
+      return {
+        userId: result.data.user.id,
+        token: result.data.session.token,
+      }
+    },
+
+    async signOut(): Promise<void> {
+      await client.signOut()
+    },
+
+    async getSession(): Promise<AuthSession | null> {
+      try {
+        const result = await client.getSession()
+        if (!result.data?.session) return null
+
+        return {
+          userId: result.data.session.userId,
+          token: result.data.session.token,
+          expiresAt: result.data.session.expiresAt,
+        }
+      } catch {
+        return null
+      }
+    },
+
+    async getUser(): Promise<AuthUser | null> {
+      try {
+        const result = await client.getSession()
+        if (!result.data?.user) return null
+
+        return {
+          id: result.data.user.id,
+          email: result.data.user.email,
+          name: result.data.user.name,
+          image: result.data.user.image,
+        }
+      } catch {
+        return null
+      }
+    },
+
+    async updateUser(updates: Partial<Pick<AuthUser, 'name' | 'image'>>): Promise<AuthUser | null> {
+      try {
+        const result = await client.updateUser(updates)
+        if (result.error) throw new Error(result.error.message)
+        if (!result.data) return null
+
+        return {
+          id: result.data.id,
+          email: result.data.email,
+          name: result.data.name,
+          image: result.data.image,
+        }
+      } catch {
+        return null
+      }
+    },
+  }
+}

package/packages/shared/src/auth/clerk.ts

@@ -0,0 +1,151 @@
+// @geenius/adapters — Clerk auth adapter
+// Wraps the Clerk client SDK to conform to AuthAdapter interface.
+// Requires: @clerk/clerk-js or @clerk/clerk-react
+
+import type { AuthUser, AuthSession } from '../types'
+import type { AuthAdapter, OAuthProvider } from './interface'
+
+interface ClerkClient {
+  signIn: {
+    create: (params: { identifier: string; password: string }) => Promise<{
+      status: string
+      createdSessionId: string | null
+    }>
+    authenticateWithRedirect: (params: {
+      strategy: string
+      redirectUrl: string
+      redirectUrlComplete: string
+    }) => Promise<void>
+  }
+  signUp: {
+    create: (params: { emailAddress: string; password: string; firstName?: string }) => Promise<{
+      status: string
+      createdSessionId: string | null
+    }>
+  }
+  signOut: () => Promise<void>
+  session: {
+    getToken: () => Promise<string | null>
+  } | null
+  user: {
+    id: string
+    primaryEmailAddress: { emailAddress: string } | null
+    firstName: string | null
+    lastName: string | null
+    imageUrl: string
+    update: (params: { firstName?: string; lastName?: string }) => Promise<any>
+  } | null
+}
+
+export interface ClerkAuthAdapterOptions {
+  /** Pre-configured Clerk client instance (e.g. from useClerk() or Clerk.load()) */
+  client: ClerkClient
+}
+
+export function createClerkAuthAdapter(options: ClerkAuthAdapterOptions): AuthAdapter {
+  const { client } = options
+
+  return {
+    async signInWithOAuth(provider: OAuthProvider, options?: { redirectUrl?: string }): Promise<{ url: string }> {
+      // Clerk's OAuth flow is browser-redirect based. We initiate the redirect;
+      // the browser navigates to the provider. The returned URL is where Clerk will
+      // redirect back to after authentication.
+      const redirectUrlComplete = options?.redirectUrl ?? window.location.origin
+      const clerkCallbackUrl = `${window.location.origin}/sign-in/sso-callback`
+      await client.signIn.authenticateWithRedirect({
+        strategy: `oauth_${provider}`,
+        redirectUrl: clerkCallbackUrl,
+        redirectUrlComplete,
+      })
+      // authenticateWithRedirect triggers a browser navigation; this return is nominal.
+      return { url: clerkCallbackUrl }
+    },
+
+    async signIn(email: string, password: string): Promise<AuthSession> {
+      const result = await client.signIn.create({ identifier: email, password })
+      if (result.status !== 'complete' || !result.createdSessionId) {
+        throw new Error('Clerk sign in failed — status: ' + result.status)
+      }
+
+      const token = await client.session?.getToken() || result.createdSessionId
+
+      return {
+        userId: client.user?.id || '',
+        token,
+      }
+    },
+
+    async signUp(email: string, password: string, name?: string): Promise<AuthSession> {
+      const result = await client.signUp.create({
+        emailAddress: email,
+        password,
+        firstName: name || email.split('@')[0],
+      })
+      if (result.status !== 'complete' || !result.createdSessionId) {
+        throw new Error('Clerk sign up failed — status: ' + result.status)
+      }
+
+      const token = await client.session?.getToken() || result.createdSessionId
+
+      return {
+        userId: client.user?.id || '',
+        token,
+      }
+    },
+
+    async signOut(): Promise<void> {
+      await client.signOut()
+    },
+
+    async getSession(): Promise<AuthSession | null> {
+      try {
+        if (!client.session) return null
+        const token = await client.session.getToken()
+        if (!token) return null
+
+        return {
+          userId: client.user?.id || '',
+          token,
+        }
+      } catch {
+        return null
+      }
+    },
+
+    async getUser(): Promise<AuthUser | null> {
+      try {
+        if (!client.user) return null
+
+        const fullName = [client.user.firstName, client.user.lastName].filter(Boolean).join(' ')
+
+        return {
+          id: client.user.id,
+          email: client.user.primaryEmailAddress?.emailAddress || '',
+          name: fullName || undefined,
+          image: client.user.imageUrl || undefined,
+        }
+      } catch {
+        return null
+      }
+    },
+
+    async updateUser(updates: Partial<Pick<AuthUser, 'name' | 'image'>>): Promise<AuthUser | null> {
+      try {
+        if (!client.user) return null
+
+        const params: Record<string, string> = {}
+        if (updates.name) {
+          const parts = updates.name.split(' ')
+          params.firstName = parts[0]
+          if (parts.length > 1) params.lastName = parts.slice(1).join(' ')
+        }
+
+        await client.user.update(params)
+
+        return this.getUser()
+      } catch {
+        return null
+      }
+    },
+  }
+}

package/packages/shared/src/auth/convex-auth.ts

@@ -0,0 +1,125 @@
+// @geenius/adapters — Convex Auth implementation (MVP tier)
+// Wraps @convex-dev/auth client hooks to conform to AuthAdapter interface.
+// Requires: convex, @convex-dev/auth
+
+import type { AuthUser, AuthSession } from '../types'
+import type { AuthAdapter, OAuthProvider } from './interface'
+
+interface ConvexAuthClient {
+  signIn: (provider: string, params: Record<string, string>) => Promise<void>
+  signOut: () => Promise<void>
+  isAuthenticated: () => boolean
+  isLoading: () => boolean
+}
+
+interface ConvexQueryClient {
+  query: (fn: any, args?: any) => Promise<any>
+  mutation: (fn: any, args?: any) => Promise<any>
+}
+
+export interface ConvexAuthAdapterOptions {
+  /** The Convex Auth client (from useConvexAuth or equivalent) */
+  authClient: ConvexAuthClient
+  /** The Convex client for running queries/mutations */
+  convexClient: ConvexQueryClient
+  /** The query function reference for getting current user */
+  getCurrentUserQuery: any
+  /** The mutation function reference for updating user */
+  updateUserMutation?: any
+}
+
+export function createConvexAuthAdapter(options: ConvexAuthAdapterOptions): AuthAdapter {
+  const { authClient, convexClient, getCurrentUserQuery, updateUserMutation } = options
+
+  return {
+    async signInWithOAuth(provider: OAuthProvider, options?: { redirectUrl?: string }): Promise<{ url: string }> {
+      // Convex Auth uses the same signIn() entry point for social providers.
+      // The provider name must match what's configured in the Convex Auth config.
+      await authClient.signIn(provider, {
+        redirectTo: options?.redirectUrl,
+      })
+      // Convex Auth manages the redirect internally; the return URL is nominal.
+      return { url: options?.redirectUrl ?? '/' }
+    },
+
+    async signIn(email: string, password: string): Promise<AuthSession> {
+      await authClient.signIn('password', { email, password, flow: 'signIn' })
+
+      // Convex Auth manages sessions internally via cookies
+      // We return a placeholder session — the real session is managed by Convex
+      return {
+        userId: '', // Will be populated by getUser()
+        token: 'convex-managed',
+      }
+    },
+
+    async signUp(email: string, password: string, name?: string): Promise<AuthSession> {
+      await authClient.signIn('password', {
+        email,
+        password,
+        name: name || email.split('@')[0],
+        flow: 'signUp',
+      })
+
+      return {
+        userId: '',
+        token: 'convex-managed',
+      }
+    },
+
+    async signOut(): Promise<void> {
+      await authClient.signOut()
+    },
+
+    async getSession(): Promise<AuthSession | null> {
+      if (!authClient.isAuthenticated()) return null
+
+      try {
+        const user = await convexClient.query(getCurrentUserQuery)
+        if (!user) return null
+
+        return {
+          userId: user._id || user.id,
+          token: 'convex-managed',
+        }
+      } catch {
+        return null
+      }
+    },
+
+    async getUser(): Promise<AuthUser | null> {
+      if (!authClient.isAuthenticated()) return null
+
+      try {
+        const user = await convexClient.query(getCurrentUserQuery)
+        if (!user) return null
+
+        return {
+          id: user._id || user.id,
+          email: user.email,
+          name: user.name,
+          image: user.image,
+          role: user.role,
+          createdAt: user._creationTime
+            ? new Date(user._creationTime).toISOString()
+            : undefined,
+        }
+      } catch {
+        return null
+      }
+    },
+
+    async updateUser(updates: Partial<Pick<AuthUser, 'name' | 'image'>>): Promise<AuthUser | null> {
+      if (!updateUserMutation) {
+        throw new Error('updateUserMutation not configured')
+      }
+
+      try {
+        await convexClient.mutation(updateUserMutation, updates)
+        return this.getUser()
+      } catch {
+        return null
+      }
+    },
+  }
+}

package/packages/shared/src/auth/index.ts

@@ -0,0 +1,10 @@
+export type { AuthAdapter, OAuthProvider } from './interface'
+export { createLocalStorageAuthAdapter } from './localStorage'
+export { createBetterAuthAdapter } from './better-auth'
+export type { BetterAuthAdapterOptions } from './better-auth'
+export { createConvexAuthAdapter } from './convex-auth'
+export type { ConvexAuthAdapterOptions } from './convex-auth'
+export { createClerkAuthAdapter } from './clerk'
+export type { ClerkAuthAdapterOptions } from './clerk'
+export { createSupabaseAuthAdapter } from './supabase-auth'
+export type { SupabaseAuthAdapterOptions } from './supabase-auth'

package/packages/shared/src/auth/interface.ts

@@ -0,0 +1,17 @@
+// @geenius/adapters — Auth adapter interface
+
+import type { AuthUser, AuthSession } from '../types'
+
+/** OAuth provider identifiers */
+export type OAuthProvider = 'google' | 'github' | 'discord' | 'twitter' | 'apple' | 'microsoft' | string
+
+export interface AuthAdapter {
+  signIn(email: string, password: string): Promise<AuthSession>
+  signUp(email: string, password: string, name?: string): Promise<AuthSession>
+  /** Initiate an OAuth sign-in flow. Returns the redirect URL for the provider. */
+  signInWithOAuth(provider: OAuthProvider, options?: { redirectUrl?: string }): Promise<{ url: string }>
+  signOut(): Promise<void>
+  getSession(): Promise<AuthSession | null>
+  getUser(): Promise<AuthUser | null>
+  updateUser(updates: Partial<Pick<AuthUser, 'name' | 'image'>>): Promise<AuthUser | null>
+}