vibefast-cli 1.1.3 → 1.2.1

package/recipes/chatbot-supabase/apps/native/src/features/chatbot/services/message-handler-service.ts

@@ -0,0 +1,189 @@
+/**
+ * Message Handler Service
+ *
+ * Handles message submission and chat operations with Supabase backend.
+ */
+
+import { Alert } from 'react-native';
+
+import { defaultCacheService } from '@/core/cache';
+import type { AppMessage } from '@/features/chatbot/types';
+import { translate } from '@/lib';
+
+export type AppAttachment = {
+  storageId: string;
+  url?: string;
+  mimeType?: string;
+  type: 'image';
+  fileName?: string;
+};
+
+type MessageSubmissionOptions = {
+  currentInput: string;
+  conversationId: string;
+  attachmentsFromInputBar?: {
+    type: 'image';
+    storageId: string;
+    fileName?: string;
+    mimeType?: string;
+    url?: string;
+  }[];
+  storeUserMessageMutation: {
+    mutateAsync: (args: {
+      conversationId: string;
+      authorType: 'user' | 'bot';
+      text?: string;
+      attachments?: {
+        type: 'image';
+        storageId: string;
+        fileName?: string;
+        mimeType?: string;
+      }[];
+    }) => Promise<{ id: string } | null>;
+  };
+};
+
+type ClearChatOptions = {
+  conversationId: string;
+  clearConversationMutation: {
+    mutateAsync: (args: { conversationId: string }) => Promise<any>;
+  };
+  onCleared?: () => void;
+};
+
+/**
+ * Service for handling message submission and chat operations
+ */
+export class MessageHandlerService {
+  /**
+   * Store a user message to the database before sending to AI
+   */
+  static async storeUserMessage(
+    options: MessageSubmissionOptions,
+  ): Promise<string | null> {
+    const {
+      currentInput,
+      conversationId,
+      attachmentsFromInputBar,
+      storeUserMessageMutation,
+    } = options;
+
+    try {
+      console.log('[MessageHandlerService] Storing user message to DB...');
+      const result = await storeUserMessageMutation.mutateAsync({
+        conversationId,
+        authorType: 'user',
+        text: currentInput.trim() || undefined,
+        attachments: attachmentsFromInputBar?.map((att) => ({
+          type: 'image',
+          storageId: att.storageId,
+          fileName: att.fileName,
+          mimeType: att.mimeType,
+          url: att.url,
+        })),
+      });
+      console.log('[MessageHandlerService] User message stored successfully.');
+      return result?.id ?? null;
+    } catch (dbError) {
+      console.error(
+        '[MessageHandlerService] Failed to store user message:',
+        dbError,
+      );
+      Alert.alert(translate('common.error'), translate('chatbot.send_failed'), [
+        {
+          text: translate('common.ok'),
+          onPress: () => {
+            // Reset the useChat hook by reloading the data
+            defaultCacheService.removeItem(`conversation_${conversationId}`);
+          },
+        },
+      ]);
+      return null;
+    }
+  }
+
+  /**
+   * Handle clearing a chat conversation
+   */
+  static clearChat(options: ClearChatOptions): void {
+    const { conversationId, clearConversationMutation } = options;
+
+    Alert.alert(
+      'Clear Chat',
+      'Are you sure you want to clear all messages? This action cannot be undone.',
+      [
+        {
+          text: 'Cancel',
+          style: 'cancel',
+        },
+        {
+          text: 'Clear',
+          style: 'destructive',
+          onPress: async () => {
+            try {
+              console.log(
+                '[MessageHandlerService] Clearing conversation:',
+                conversationId,
+              );
+              await clearConversationMutation.mutateAsync({
+                conversationId,
+              });
+              console.log(
+                '[MessageHandlerService] Conversation cleared successfully',
+              );
+
+              // Reset the useChat hook by reloading the data
+              defaultCacheService.removeItem(`conversation_${conversationId}`);
+              options.onCleared?.();
+            } catch (error) {
+              console.error(
+                '[MessageHandlerService] Failed to clear conversation:',
+                error,
+              );
+              Alert.alert('Error', 'Failed to clear chat. Please try again.');
+            }
+          },
+        },
+      ],
+    );
+  }
+
+  /**
+   * Transform display messages with stable attachment mapping
+   */
+  static transformDisplayMessages(
+    liveMessages: AppMessage[],
+    persistedMessages: AppMessage[],
+    lastUserAttachments?: AppAttachment[],
+    attachmentCache?: Record<string, AppAttachment[]>,
+  ): AppMessage[] {
+    const persisted = new Map(persistedMessages.map((m) => [m.id, m]));
+    const lastUserIdx = [...liveMessages]
+      .map((m, i) => ({ m, i }))
+      .reverse()
+      .find((x) => x.m.role === 'user')?.i;
+
+    return liveMessages.map((m, i) => {
+      const fromDb = persisted.get(m.id);
+      const isMostRecentUser = m.role === 'user' && i === lastUserIdx;
+      // Attachment precedence:
+      // 1) Cached attachments for this live message ID (persist across renders)
+      // 2) Most recent user's optimistic attachments (for immediate display)
+      // 3) Attachments from persisted DB messages when IDs align
+      const fromCache = attachmentCache?.[m.id];
+      const attachments =
+        fromCache && fromCache.length
+          ? fromCache
+          : ((isMostRecentUser && lastUserAttachments?.length
+              ? lastUserAttachments
+              : fromDb?.attachments) ?? undefined);
+
+      return {
+        ...m,
+        attachments,
+        toolCalls: m.toolCalls ?? fromDb?.toolCalls,
+        metadata: m.metadata ?? fromDb?.metadata,
+      };
+    });
+  }
+}

package/recipes/chatbot-supabase/apps/native/src/features/chatbot/types/index.ts

@@ -0,0 +1,70 @@
+/**
+ * Chatbot Types
+ *
+ * Types for the chatbot feature using Supabase backend.
+ */
+
+export type LocalMessageContentPart =
+  | { type: 'text'; text: string }
+  | { type: 'image'; image: string | URL };
+
+export type MessageAttachment = {
+  type: 'image';
+  storageId: string;
+  url?: string;
+  fileName?: string;
+  mimeType?: string;
+};
+
+export type ToolCallRecord = {
+  toolName: string;
+  args: unknown;
+  result?: unknown;
+};
+
+export type MessageMetadata = {
+  streamId?: string;
+  status?: string;
+  usage?: {
+    promptTokens?: number;
+    completionTokens?: number;
+    totalTokens?: number;
+  };
+};
+
+export type AgentStatus =
+  | {
+      type: 'thinking';
+      label?: string | null;
+      startedAt: number;
+    }
+  | {
+      type: 'tool';
+      toolName: string;
+      label?: string | null;
+      startedAt: number;
+    };
+
+export type AppMessage = {
+  id: string;
+  role: 'user' | 'assistant' | 'data';
+  content: string | LocalMessageContentPart[];
+  createdAt?: Date;
+  parts?: unknown; // Optional hook into AI SDK shapes when present
+  attachments?: MessageAttachment[];
+  toolCalls?: ToolCallRecord[];
+  metadata?: MessageMetadata;
+};
+
+export type ConversationMessageFromDB = {
+  id: string;
+  created_at: string;
+  author_type: 'user' | 'bot';
+  text?: string | null;
+  attachments?: MessageAttachment[] | null;
+  tool_calls?: ToolCallRecord[] | null;
+  metadata?: MessageMetadata | null;
+};
+
+// Legacy type alias for backward compatibility
+/** @deprecated Use MessageAttachment instead */

package/recipes/chatbot-supabase/apps/native/src/features/chatbot/utils/chat-telemetry.ts

@@ -0,0 +1,91 @@
+import type { TelemetryMode } from '@/core/config';
+import { getChatTelemetryMode } from '@/core/config/telemetry';
+
+const DEFAULT_SAMPLE_PROBABILITY = 0.1;
+
+type TimelineEntry = {
+  label: string;
+  msFromStart: number;
+  data?: Record<string, unknown>;
+};
+
+export type ChatTelemetryTracker = {
+  readonly event: string;
+  mark: (label: string, data?: Record<string, unknown>) => void;
+  finalize: (status: 'ok' | 'error', extra?: Record<string, unknown>) => void;
+};
+
+function shouldTrack(mode: TelemetryMode, probability: number): boolean {
+  if (mode === 'off') {
+    return false;
+  }
+  if (mode === 'debug') {
+    return true;
+  }
+
+  const clampedProbability = Math.min(Math.max(probability, 0), 1);
+  return Math.random() < clampedProbability;
+}
+
+export function createChatTelemetryTracker(
+  event: string,
+  baseContext: Record<string, unknown>,
+  sampleProbability = DEFAULT_SAMPLE_PROBABILITY,
+): ChatTelemetryTracker | null {
+  const mode = getChatTelemetryMode();
+  if (!shouldTrack(mode, sampleProbability)) {
+    return null;
+  }
+
+  const start = Date.now();
+  const timeline: TimelineEntry[] = [{ label: 'start', msFromStart: 0 }];
+  let finalized = false;
+
+  return {
+    event,
+    mark(label, data) {
+      if (finalized) {
+        return;
+      }
+      const elapsed = Date.now() - start;
+      timeline.push({
+        label,
+        msFromStart: elapsed,
+        data,
+      });
+    },
+    finalize(status, extra) {
+      if (finalized) {
+        return;
+      }
+      finalized = true;
+      const totalMs = Date.now() - start;
+      console.log('[chat][telemetry]', {
+        event,
+        mode,
+        status,
+        totalMs,
+        ...baseContext,
+        ...(extra ?? {}),
+        timeline,
+      });
+    },
+  };
+}
+
+export function logChatTelemetryEvent(
+  event: string,
+  payload: Record<string, unknown>,
+  sampleProbability = DEFAULT_SAMPLE_PROBABILITY,
+) {
+  const mode = getChatTelemetryMode();
+  if (!shouldTrack(mode, sampleProbability)) {
+    return;
+  }
+
+  console.log('[chat][telemetry]', {
+    event,
+    mode,
+    ...payload,
+  });
+}

package/recipes/chatbot-supabase/packages/backend/src/services/conversations.ts

@@ -0,0 +1,243 @@
+/**
+ * Conversations Service
+ *
+ * Handles conversation operations including getOrCreateDefault, create, list, and delete.
+ *
+ * Requirements: 4.1, 4.2
+ */
+
+import type { SupabaseClientType } from '../lib/supabase';
+import type { Conversation } from '../types';
+
+const DEFAULT_CONVERSATION_NAME = 'Default Chat';
+
+export interface GetConversationResult {
+  success: boolean;
+  conversation?: Conversation;
+  error?: string;
+}
+
+export interface ListConversationsResult {
+  success: boolean;
+  conversations?: Conversation[];
+  error?: string;
+}
+
+export interface DeleteConversationResult {
+  success: boolean;
+  error?: string;
+}
+
+/**
+ * Get or create the default conversation for the current user
+ *
+ * This function returns an existing conversation named "Default Chat" or creates
+ * a new one if it doesn't exist. This ensures idempotency - calling multiple times
+ * always returns the same conversation.
+ *
+ * @param supabase - Supabase client (authenticated)
+ * @returns The default conversation
+ *
+ * Requirements: 4.1
+ */
+export async function getOrCreateDefault(
+  supabase: SupabaseClientType
+): Promise<GetConversationResult> {
+  // Get the current auth user
+  const { data: authData, error: authError } = await supabase.auth.getUser();
+
+  if (authError || !authData.user) {
+    return { success: false, error: 'Not authenticated' };
+  }
+
+  const userId = authData.user.id;
+
+  // Try to find existing default conversation (use limit 1 to handle duplicates)
+  const { data: existingList, error: findError } = await supabase
+    .from('conversations')
+    .select('*')
+    .eq('user_id', userId)
+    .eq('name', DEFAULT_CONVERSATION_NAME)
+    .order('created_at', { ascending: true })
+    .limit(1);
+
+  if (findError) {
+    return { success: false, error: `Failed to find conversation: ${findError.message}` };
+  }
+
+  // Return existing if found
+  if (existingList && existingList.length > 0) {
+    return { success: true, conversation: existingList[0] };
+  }
+
+  // Create new default conversation
+  const { data: created, error: createError } = await supabase
+    .from('conversations')
+    .insert({
+      user_id: userId,
+      name: DEFAULT_CONVERSATION_NAME,
+    })
+    .select()
+    .single();
+
+  if (createError) {
+    return { success: false, error: `Failed to create conversation: ${createError.message}` };
+  }
+
+  return { success: true, conversation: created };
+}
+
+
+/**
+ * Create a new conversation
+ *
+ * @param supabase - Supabase client (authenticated)
+ * @param name - Optional name for the conversation
+ * @returns The created conversation
+ *
+ * Requirements: 4.2
+ */
+export async function create(
+  supabase: SupabaseClientType,
+  name?: string
+): Promise<GetConversationResult> {
+  // Get the current auth user
+  const { data: authData, error: authError } = await supabase.auth.getUser();
+
+  if (authError || !authData.user) {
+    return { success: false, error: 'Not authenticated' };
+  }
+
+  const { data: conversation, error: createError } = await supabase
+    .from('conversations')
+    .insert({
+      user_id: authData.user.id,
+      name: name || null,
+    })
+    .select()
+    .single();
+
+  if (createError) {
+    return { success: false, error: `Failed to create conversation: ${createError.message}` };
+  }
+
+  return { success: true, conversation };
+}
+
+/**
+ * List all conversations for the current user
+ *
+ * @param supabase - Supabase client (authenticated)
+ * @returns List of conversations ordered by creation time (newest first)
+ *
+ * Requirements: 4.2
+ */
+export async function list(
+  supabase: SupabaseClientType
+): Promise<ListConversationsResult> {
+  // Get the current auth user
+  const { data: authData, error: authError } = await supabase.auth.getUser();
+
+  if (authError || !authData.user) {
+    return { success: false, error: 'Not authenticated' };
+  }
+
+  const { data: conversations, error: listError } = await supabase
+    .from('conversations')
+    .select('*')
+    .eq('user_id', authData.user.id)
+    .order('created_at', { ascending: false });
+
+  if (listError) {
+    return { success: false, error: `Failed to list conversations: ${listError.message}` };
+  }
+
+  return { success: true, conversations: conversations || [] };
+}
+
+/**
+ * Delete a conversation
+ *
+ * This will also delete all messages in the conversation due to CASCADE.
+ *
+ * @param supabase - Supabase client (authenticated)
+ * @param conversationId - The ID of the conversation to delete
+ * @returns Success or error
+ *
+ * Requirements: 4.2
+ */
+export async function deleteConversation(
+  supabase: SupabaseClientType,
+  conversationId: string
+): Promise<DeleteConversationResult> {
+  // Get the current auth user
+  const { data: authData, error: authError } = await supabase.auth.getUser();
+
+  if (authError || !authData.user) {
+    return { success: false, error: 'Not authenticated' };
+  }
+
+  if (!conversationId) {
+    return { success: false, error: 'Conversation ID is required' };
+  }
+
+  // Delete the conversation (RLS ensures user can only delete their own)
+  const { error: deleteError } = await supabase
+    .from('conversations')
+    .delete()
+    .eq('id', conversationId)
+    .eq('user_id', authData.user.id);
+
+  if (deleteError) {
+    return { success: false, error: `Failed to delete conversation: ${deleteError.message}` };
+  }
+
+  return { success: true };
+}
+
+/**
+ * Get a conversation by ID
+ *
+ * @param supabase - Supabase client (authenticated)
+ * @param conversationId - The ID of the conversation
+ * @returns The conversation or error
+ */
+export async function getById(
+  supabase: SupabaseClientType,
+  conversationId: string
+): Promise<GetConversationResult> {
+  // Get the current auth user
+  const { data: authData, error: authError } = await supabase.auth.getUser();
+
+  if (authError || !authData.user) {
+    return { success: false, error: 'Not authenticated' };
+  }
+
+  if (!conversationId) {
+    return { success: false, error: 'Conversation ID is required' };
+  }
+
+  const { data: conversation, error: getError } = await supabase
+    .from('conversations')
+    .select('*')
+    .eq('id', conversationId)
+    .eq('user_id', authData.user.id)
+    .single();
+
+  if (getError) {
+    if (getError.code === 'PGRST116') {
+      return { success: false, error: 'Conversation not found' };
+    }
+    return { success: false, error: `Failed to get conversation: ${getError.message}` };
+  }
+
+  return { success: true, conversation };
+}
+
+export const conversationsService = {
+  getOrCreateDefault,
+  create,
+  list,
+  delete: deleteConversation,
+  getById,
+};