Supabase

app/actions.tsx

@@ -17,6 +17,7 @@ import { inquire, researcher, taskManager, querySuggestor, resolutionSearch } fr
 // The geospatialTool (if used by agents like researcher) now manages its own MCP client.
 import { writer } from '@/lib/agents/writer'
 import { saveChat, getSystemPrompt } from '@/lib/actions/chat' // Added getSystemPrompt
+import { retrieveContext } from '@/lib/actions/rag'
 import { Chat, AIMessage } from '@/lib/types'
 import { UserMessage } from '@/components/user-message'
 import { BotMessage } from '@/components/message'
@@ -284,6 +285,11 @@ async function submit(formData?: FormData, skip?: boolean) {
   const userId = 'anonymous'
   const currentSystemPrompt = (await getSystemPrompt(userId)) || ''
 
+  const retrievedContext = await retrieveContext(userInput, aiState.get().chatId)
+  const augmentedSystemPrompt = retrievedContext.length > 0
+    ? `Context: ${retrievedContext.join('\n')}\n${currentSystemPrompt}`
+    : currentSystemPrompt
+
   async function processEvents() {
     let action: any = { object: { next: 'proceed' } }
     if (!skip) action = (await taskManager(messages)) ?? action
@@ -320,7 +326,7 @@ async function submit(formData?: FormData, skip?: boolean) {
         : answer.length === 0 && !errorOccurred
     ) {
       const { fullResponse, hasError, toolResponses } = await researcher(
-        currentSystemPrompt,
+        augmentedSystemPrompt,
         uiStream,
         streamText,
         messages,
@@ -565,14 +571,23 @@ export const getUIStateFromAIState = (aiState: AIState): UIState => {
                 // New messages will store the content array or string directly
                 messageContent = content
               }
+              const location = (message as any).locations
               return {
                 id,
                 component: (
-                  <UserMessage
-                    content={messageContent}
-                    chatId={chatId}
-                    showShare={index === 0 && !isSharePage}
-                  />
+                  <>
+                    <UserMessage
+                      content={messageContent}
+                      chatId={chatId}
+                      showShare={index === 0 && !isSharePage}
+                    />
+                    {location && (
+                      <GeoJsonLayer
+                        id={`${id}-geojson`}
+                        data={location.geojson}
+                      />
+                    )}
+                  </>
                 )
               }
             case 'inquiry':

app/api/chat/route.ts

@@ -1,11 +1,9 @@
 import { NextResponse, NextRequest } from 'next/server';
-import { saveChat, createMessage, NewChat, NewMessage } from '@/lib/actions/chat-db';
+import { saveChat } from '@/lib/actions/chat';
 import { getCurrentUserIdOnServer } from '@/lib/auth/get-current-user';
-// import { generateUUID } from '@/lib/utils'; // Assuming generateUUID is in lib/utils as per PR context - not needed for PKs
+import { type Chat } from '@/lib/types';
+import { v4 as uuidv4 } from 'uuid';
 
-// This is a simplified POST handler. PR #533's version might be more complex,
-// potentially handling streaming AI responses and then saving.
-// For now, this focuses on the database interaction part.
 export async function POST(request: NextRequest) {
   try {
     const userId = await getCurrentUserIdOnServer();
@@ -14,47 +12,35 @@ export async function POST(request: NextRequest) {
     }
 
     const body = await request.json();
-
-    // Example: Distinguish between creating a new chat vs. adding a message to existing chat
-    // The actual structure of `body` would depend on client-side implementation.
-    // Let's assume a simple case: creating a new chat with an initial message.
-    const { title, initialMessageContent, role = 'user' } = body;
+    const { title, initialMessageContent, role = 'user' }
+    = body;
 
     if (!initialMessageContent) {
         return NextResponse.json({ error: 'Initial message content is required' }, { status: 400 });
     }
 
-    const newChatData: NewChat = {
-      // id: generateUUID(), // Drizzle schema now has defaultRandom for UUIDs
+    const newChat: Chat = {
+      id: uuidv4(),
       userId: userId,
-      title: title || 'New Chat', // Default title if not provided
-      // createdAt: new Date(), // Handled by defaultNow() in schema
-      visibility: 'private', // Default visibility
-    };
-
-    // Use a transaction if creating chat and first message together
-    // For simplicity here, let's assume saveChat handles chat creation and returns ID, then we create a message.
-    // A more robust `saveChat` might create the chat and first message in one go.
-    // The `saveChat` in chat-db.ts is designed to handle this.
-
-    const firstMessage: Omit<NewMessage, 'chatId'> = {
-        // id: generateUUID(), // Drizzle schema now has defaultRandom for UUIDs
-        // chatId is omitted as it will be set by saveChat
-        userId: userId,
-        role: role as NewMessage['role'], // Ensure role type matches schema expectation
-        content: initialMessageContent,
-        // createdAt: new Date(), // Handled by defaultNow() in schema, not strictly needed here
+      title: title || 'New Chat',
+      createdAt: new Date(),
+      path: '',
+      messages: [
+        {
+          id: uuidv4(),
+          role: role,
+          content: initialMessageContent,
+          createdAt: new Date(),
+        }
+      ]
     };
 
-    // The saveChat in chat-db.ts is designed to take initial messages.
-    const savedChatId = await saveChat(newChatData, [firstMessage]);
+    const savedChatId = await saveChat(newChat, userId);
 
     if (!savedChatId) {
          return NextResponse.json({ error: 'Failed to save chat' }, { status: 500 });
     }
 
-    // Fetch the newly created chat and message to return (optional, but good for client)
-    // For now, just return success and the new chat ID.
     return NextResponse.json({ message: 'Chat created successfully', chatId: savedChatId }, { status: 201 });
 
   } catch (error) {

app/api/chats/all/route.ts

@@ -1,8 +1,6 @@
-// Content for app/api/chats/all/route.ts
 import { NextResponse } from 'next/server';
-import { clearHistory as dbClearHistory } from '@/lib/actions/chat-db';
+import { clearChats } from '@/lib/actions/chat';
 import { getCurrentUserIdOnServer } from '@/lib/auth/get-current-user';
-import { revalidatePath } from 'next/cache'; // For revalidating after clearing
 
 export async function DELETE() {
   try {
@@ -11,26 +9,18 @@ export async function DELETE() {
       return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
     }
 
-    const success = await dbClearHistory(userId);
-    if (success) {
-      revalidatePath('/'); // Revalidate home or relevant pages
-      revalidatePath('/search'); // Revalidate search path
-      return NextResponse.json({ message: 'History cleared successfully' }, { status: 200 });
-    } else {
-      // This case might be redundant if dbClearHistory throws an error on failure,
-      // but kept for explicitness if it returns false for "no error but nothing done".
-      return NextResponse.json({ error: 'Failed to clear history' }, { status: 500 });
+    const result = await clearChats(userId);
+    if (result && 'error' in result) {
+        return NextResponse.json({ error: result.error }, { status: 500 });
     }
+
+    return NextResponse.json({ message: 'History cleared successfully' }, { status: 200 });
+
   } catch (error) {
     console.error('Error clearing history via API:', error);
     let errorMessage = 'Internal Server Error clearing history';
     if (error instanceof Error && error.message) {
-        // Use the error message from dbClearHistory if available (e.g., "User ID is required")
-        // This depends on dbClearHistory actually throwing or returning specific error messages.
-        // The current dbClearHistory in chat.ts returns {error: ...} which won't be caught here as an Error instance directly.
-        // However, the dbClearHistory in chat-db.ts returns boolean.
-        // Let's assume if dbClearHistory from chat-db.ts (which returns boolean) fails, it's a generic 500.
-        // If it were to throw, that would be caught.
+        errorMessage = error.message
     }
     return NextResponse.json({ error: errorMessage }, { status: 500 });
   }

app/api/chats/route.ts

@@ -1,5 +1,5 @@
 import { NextResponse, NextRequest } from 'next/server';
-import { getChatsPage } from '@/lib/actions/chat-db';
+import { getChats } from '@/lib/actions/chat';
 import { getCurrentUserIdOnServer } from '@/lib/auth/get-current-user';
 
 export async function GET(request: NextRequest) {
@@ -9,24 +9,8 @@ export async function GET(request: NextRequest) {
       return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
     }
 
-    const { searchParams } = new URL(request.url);
-
-    const DEFAULT_LIMIT = 20;
-    const MAX_LIMIT = 100;
-    const DEFAULT_OFFSET = 0;
-
-    let limit = parseInt(searchParams.get('limit') || '', 10);
-    if (isNaN(limit) || limit < 1 || limit > MAX_LIMIT) {
-      limit = DEFAULT_LIMIT;
-    }
-
-    let offset = parseInt(searchParams.get('offset') || '', 10);
-    if (isNaN(offset) || offset < 0) {
-      offset = DEFAULT_OFFSET;
-    }
-
-    const result = await getChatsPage(userId, limit, offset);
-    return NextResponse.json(result);
+    const chats = await getChats(userId);
+    return NextResponse.json({ chats });
   } catch (error) {
     console.error('Error fetching chats:', error);
     return NextResponse.json({ error: 'Internal Server Error fetching chats' }, { status: 500 });

app/search/[id]/page.tsx

@@ -1,76 +1,51 @@
 import { notFound, redirect } from 'next/navigation';
 import { Chat } from '@/components/chat';
-import { getChat, getChatMessages } from '@/lib/actions/chat'; // Added getChatMessages
+import { getChat, getChatMessages } from '@/lib/actions/chat';
 import { AI } from '@/app/actions';
 import { MapDataProvider } from '@/components/map/map-data-context';
-import { getCurrentUserIdOnServer } from '@/lib/auth/get-current-user'; // For server-side auth
-import type { AIMessage } from '@/lib/types'; // For AIMessage type
-import type { Message as DrizzleMessage } from '@/lib/actions/chat-db'; // For DrizzleMessage type
+import { getCurrentUserIdOnServer } from '@/lib/auth/get-current-user';
+import type { AIMessage } from '@/lib/types';
 
 export const maxDuration = 60;
 
 export interface SearchPageProps {
-  params: Promise<{ id: string }>; // Keep as is for now
+  params: Promise<{ id: string }>;
 }
 
 export async function generateMetadata({ params }: SearchPageProps) {
-  const { id } = await params; // Keep as is for now
-  // TODO: Metadata generation might need authenticated user if chats are private
-  // For now, assuming getChat can be called or it handles anon access for metadata appropriately
-  const userId = await getCurrentUserIdOnServer(); // Attempt to get user for metadata
-  const chat = await getChat(id, userId || 'anonymous'); // Pass userId or 'anonymous' if none
+  const { id } = await params;
+  const chat = await getChat(id);
   return {
     title: chat?.title?.toString().slice(0, 50) || 'Search',
   };
 }
 
 export default async function SearchPage({ params }: SearchPageProps) {
-  const { id } = await params; // Keep as is for now
+  const { id } = await params;
   const userId = await getCurrentUserIdOnServer();
 
   if (!userId) {
-    // If no user, redirect to login or show appropriate page
-    // For now, redirecting to home, but a login page would be better.
     redirect('/');
   }
 
-  const chat = await getChat(id, userId);
+  const chat = await getChat(id);
 
   if (!chat) {
-    // If chat doesn't exist or user doesn't have access (handled by getChat)
     notFound();
   }
 
-  // Fetch messages for the chat
-  const dbMessages: DrizzleMessage[] = await getChatMessages(chat.id);
-
-  // Transform DrizzleMessages to AIMessages
-  const initialMessages: AIMessage[] = dbMessages.map((dbMsg): AIMessage => {
-    return {
-      id: dbMsg.id,
-      role: dbMsg.role as AIMessage['role'], // Cast role, ensure AIMessage['role'] includes all dbMsg.role possibilities
-      content: dbMsg.content,
-      createdAt: dbMsg.createdAt ? new Date(dbMsg.createdAt) : undefined,
-      // 'type' and 'name' are not in the basic Drizzle 'messages' schema.
-      // These would be undefined unless specific logic is added to derive them.
-      // For instance, if a message with role 'tool' should have a 'name',
-      // or if some messages have a specific 'type' based on content or other flags.
-      // This mapping assumes standard user/assistant messages primarily.
-    };
-  });
+  const initialMessages = await getChatMessages(chat.id);
 
   return (
     <AI
       initialAIState={{
         chatId: chat.id,
-        messages: initialMessages, // Use the transformed messages from the database
-        // isSharePage: true, // This was in PR#533, but share functionality is removed.
-                             // If needed for styling or other logic, it can be set.
+        messages: initialMessages as AIMessage[],
       }}
     >
       <MapDataProvider>
         <Chat id={id} />
       </MapDataProvider>
     </AI>
   );
-}
+}

components/chat-panel.tsx

@@ -3,7 +3,6 @@
 import { useEffect, useState, useRef, ChangeEvent, forwardRef, useImperativeHandle } from 'react'
 import type { AI, UIState } from '@/app/actions'
 import { useUIState, useActions } from 'ai/rsc'
-// Removed import of useGeospatialToolMcp as it's no longer used/available
 import { cn } from '@/lib/utils'
 import { UserMessage } from './user-message'
 import { Button } from './ui/button'
@@ -15,16 +14,17 @@ interface ChatPanelProps {
   messages: UIState
   input: string
   setInput: (value: string) => void
+  chatId: string
+  shareableLink: string
 }
 
 export interface ChatPanelRef {
   handleAttachmentClick: () => void;
 }
 
-export const ChatPanel = forwardRef<ChatPanelRef, ChatPanelProps>(({ messages, input, setInput }, ref) => {
+export const ChatPanel = forwardRef<ChatPanelRef, ChatPanelProps>(({ messages, input, setInput, chatId, shareableLink }, ref) => {
   const [, setMessages] = useUIState<typeof AI>()
   const { submit, clearChat } = useActions()
-  // Removed mcp instance as it's no longer passed to submit
   const [isMobile, setIsMobile] = useState(false)
   const [selectedFile, setSelectedFile] = useState<File | null>(null)
   const inputRef = useRef<HTMLTextAreaElement>(null)
@@ -37,7 +37,6 @@ export const ChatPanel = forwardRef<ChatPanelRef, ChatPanelProps>(({ messages, i
     }
   }));
 
-  // Detect mobile layout
   useEffect(() => {
     const checkMobile = () => {
       setIsMobile(window.innerWidth <= 1024)
@@ -116,7 +115,6 @@ export const ChatPanel = forwardRef<ChatPanelRef, ChatPanelProps>(({ messages, i
     inputRef.current?.focus()
   }, [])
 
-  // New chat button (appears when there are messages)
   if (messages.length > 0 && !isMobile) {
     return (
       <div
@@ -172,7 +170,7 @@ export const ChatPanel = forwardRef<ChatPanelRef, ChatPanelProps>(({ messages, i
         <div
           className={cn(
             'relative flex items-start w-full',
-            isMobile && 'mobile-chat-input' // Apply mobile chat input styling
+            isMobile && 'mobile-chat-input'
           )}
         >
           <input