@cortexmemory/cli 0.27.1 → 0.27.3

package/templates/vercel-ai-quickstart/app/api/auth/check/route.ts

@@ -0,0 +1,30 @@
+/**
+ * Auth Check API Route
+ *
+ * GET: Check if admin has been set up (first-run detection)
+ */
+
+import { getCortex } from "@/lib/cortex";
+
+const ADMIN_NAMESPACE = "quickstart-config";
+const ADMIN_KEY = "admin_password_hash";
+
+export async function GET() {
+  try {
+    const cortex = getCortex();
+
+    // Check if admin password hash exists in mutable store
+    const adminHash = await cortex.mutable.get(ADMIN_NAMESPACE, ADMIN_KEY);
+
+    return Response.json({
+      isSetup: adminHash !== null,
+    });
+  } catch (error) {
+    console.error("[Auth Check Error]", error);
+
+    return Response.json(
+      { error: "Failed to check admin setup status" },
+      { status: 500 }
+    );
+  }
+}

package/templates/vercel-ai-quickstart/app/api/auth/login/route.ts

@@ -0,0 +1,83 @@
+/**
+ * User Login API Route
+ *
+ * POST: Authenticate user and return session
+ */
+
+import { getCortex } from "@/lib/cortex";
+import { verifyPassword, generateSessionToken } from "@/lib/password";
+
+export async function POST(req: Request) {
+  try {
+    const body = await req.json();
+    const { username, password } = body;
+
+    // Validate input
+    if (!username || typeof username !== "string") {
+      return Response.json(
+        { error: "Username is required" },
+        { status: 400 }
+      );
+    }
+
+    if (!password || typeof password !== "string") {
+      return Response.json(
+        { error: "Password is required" },
+        { status: 400 }
+      );
+    }
+
+    const cortex = getCortex();
+    const sanitizedUsername = username.toLowerCase();
+
+    // Get user profile
+    const user = await cortex.users.get(sanitizedUsername);
+    if (!user) {
+      return Response.json(
+        { error: "Invalid username or password" },
+        { status: 401 }
+      );
+    }
+
+    // Verify password
+    const storedHash = user.data.passwordHash as string;
+    if (!storedHash) {
+      return Response.json(
+        { error: "Invalid username or password" },
+        { status: 401 }
+      );
+    }
+
+    const isValid = await verifyPassword(password, storedHash);
+    if (!isValid) {
+      return Response.json(
+        { error: "Invalid username or password" },
+        { status: 401 }
+      );
+    }
+
+    // Update last login time
+    await cortex.users.update(sanitizedUsername, {
+      lastLoginAt: Date.now(),
+    });
+
+    // Generate session token
+    const sessionToken = generateSessionToken();
+
+    return Response.json({
+      success: true,
+      user: {
+        id: sanitizedUsername,
+        displayName: (user.data.displayName as string) || sanitizedUsername,
+      },
+      sessionToken,
+    });
+  } catch (error) {
+    console.error("[Login Error]", error);
+
+    return Response.json(
+      { error: "Failed to authenticate" },
+      { status: 500 }
+    );
+  }
+}

package/templates/vercel-ai-quickstart/app/api/auth/register/route.ts

@@ -0,0 +1,94 @@
+/**
+ * User Registration API Route
+ *
+ * POST: Register a new user account
+ */
+
+import { getCortex } from "@/lib/cortex";
+import { hashPassword, generateSessionToken } from "@/lib/password";
+
+export async function POST(req: Request) {
+  try {
+    const body = await req.json();
+    const { username, password, displayName } = body;
+
+    // Validate input
+    if (!username || typeof username !== "string") {
+      return Response.json(
+        { error: "Username is required" },
+        { status: 400 }
+      );
+    }
+
+    if (!password || typeof password !== "string") {
+      return Response.json(
+        { error: "Password is required" },
+        { status: 400 }
+      );
+    }
+
+    if (username.length < 2) {
+      return Response.json(
+        { error: "Username must be at least 2 characters" },
+        { status: 400 }
+      );
+    }
+
+    if (password.length < 4) {
+      return Response.json(
+        { error: "Password must be at least 4 characters" },
+        { status: 400 }
+      );
+    }
+
+    // Sanitize username (alphanumeric, underscore, hyphen only)
+    const sanitizedUsername = username.toLowerCase().replace(/[^a-z0-9_-]/g, "");
+    if (sanitizedUsername !== username.toLowerCase()) {
+      return Response.json(
+        { error: "Username can only contain letters, numbers, underscores, and hyphens" },
+        { status: 400 }
+      );
+    }
+
+    const cortex = getCortex();
+
+    // Check if user already exists
+    const existingUser = await cortex.users.get(sanitizedUsername);
+    if (existingUser) {
+      return Response.json(
+        { error: "Username already taken" },
+        { status: 409 }
+      );
+    }
+
+    // Hash password and create user profile
+    const passwordHash = await hashPassword(password);
+    const now = Date.now();
+
+    await cortex.users.update(sanitizedUsername, {
+      displayName: displayName || sanitizedUsername,
+      passwordHash,
+      createdAt: now,
+      lastLoginAt: now,
+    });
+
+    // Generate session token
+    const sessionToken = generateSessionToken();
+
+    return Response.json({
+      success: true,
+      user: {
+        id: sanitizedUsername,
+        displayName: displayName || sanitizedUsername,
+      },
+      sessionToken,
+    });
+  } catch (error) {
+    console.error("[Register Error]", error);
+
+    return Response.json(
+      { error: "Failed to register user" },
+      { status: 500 }
+    );
+  }
+}

package/templates/vercel-ai-quickstart/app/api/auth/setup/route.ts

@@ -0,0 +1,59 @@
+/**
+ * Admin Setup API Route
+ *
+ * POST: Set up initial admin password (first-run only)
+ */
+
+import { getCortex } from "@/lib/cortex";
+import { hashPassword } from "@/lib/password";
+
+const ADMIN_NAMESPACE = "quickstart-config";
+const ADMIN_KEY = "admin_password_hash";
+
+export async function POST(req: Request) {
+  try {
+    const body = await req.json();
+    const { password } = body;
+
+    if (!password || typeof password !== "string") {
+      return Response.json(
+        { error: "Password is required" },
+        { status: 400 }
+      );
+    }
+
+    if (password.length < 4) {
+      return Response.json(
+        { error: "Password must be at least 4 characters" },
+        { status: 400 }
+      );
+    }
+
+    const cortex = getCortex();
+
+    // Check if admin already exists
+    const existingHash = await cortex.mutable.get(ADMIN_NAMESPACE, ADMIN_KEY);
+    if (existingHash !== null) {
+      return Response.json(
+        { error: "Admin already configured" },
+        { status: 409 }
+      );
+    }
+
+    // Hash and store admin password
+    const passwordHash = await hashPassword(password);
+    await cortex.mutable.set(ADMIN_NAMESPACE, ADMIN_KEY, passwordHash);
+
+    return Response.json({
+      success: true,
+      message: "Admin password configured successfully",
+    });
+  } catch (error) {
+    console.error("[Admin Setup Error]", error);
+
+    return Response.json(
+      { error: "Failed to configure admin password" },
+      { status: 500 }
+    );
+  }
+}

package/templates/vercel-ai-quickstart/app/api/chat/route.ts

@@ -11,6 +11,7 @@ import {
   createUIMessageStream,
   createUIMessageStreamResponse,
 } from "ai";
+import { getCortex } from "@/lib/cortex";
 
 // Create OpenAI client for embeddings
 const openaiClient = createOpenAI({ apiKey: process.env.OPENAI_API_KEY });
@@ -40,6 +41,7 @@ Example interactions:
 function getCortexMemoryConfig(
   memorySpaceId: string,
   userId: string,
+  conversationId: string,
   layerObserver?: LayerObserver,
 ): CortexMemoryConfig {
   return {
@@ -54,6 +56,9 @@ function getCortexMemoryConfig(
     agentId: "quickstart-assistant",
     agentName: "Cortex Demo Assistant",
 
+    // Conversation ID for chat history isolation
+    conversationId,
+
     // Enable graph memory sync (auto-configured via env vars)
     // When true, uses CypherGraphAdapter to sync to Neo4j/Memgraph
     enableGraphMemory: process.env.CORTEX_GRAPH_SYNC === "true",
@@ -101,10 +106,31 @@ function getCortexMemoryConfig(
   };
 }
 
+/**
+ * Generate a title from the first user message
+ */
+function generateTitle(message: string): string {
+  // Take first 50 chars, cut at word boundary
+  let title = message.slice(0, 50);
+  if (message.length > 50) {
+    const lastSpace = title.lastIndexOf(" ");
+    if (lastSpace > 20) {
+      title = title.slice(0, lastSpace);
+    }
+    title += "...";
+  }
+  return title;
+}
+
 export async function POST(req: Request) {
   try {
     const body = await req.json();
-    const { messages, memorySpaceId, userId } = body;
+    const { messages, memorySpaceId, userId, conversationId: providedConversationId } = body;
+
+    // Generate conversation ID if not provided (new chat)
+    const conversationId = providedConversationId || 
+      `conv-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const isNewConversation = !providedConversationId;
 
     // Convert UIMessage[] from useChat to ModelMessage[] for streamText
     // Note: In AI SDK v6+, convertToModelMessages may return a Promise
@@ -114,6 +140,28 @@ export async function POST(req: Request) {
         ? await modelMessagesResult
         : modelMessagesResult;
 
+    // Get the first user message for title generation
+    // AI SDK v5+ uses `parts` array instead of `content` string
+    const firstUserMessage = messages.find((m: { role: string }) => m.role === "user") as {
+      role: string;
+      content?: string;
+      parts?: Array<{ type: string; text?: string }>;
+    } | undefined;
+    
+    let messageText = "";
+    if (firstUserMessage) {
+      if (typeof firstUserMessage.content === "string") {
+        // Legacy format: content is a string
+        messageText = firstUserMessage.content;
+      } else if (firstUserMessage.parts && Array.isArray(firstUserMessage.parts)) {
+        // AI SDK v5+ format: extract text from parts array
+        messageText = firstUserMessage.parts
+          .filter((part) => part.type === "text" && part.text)
+          .map((part) => part.text)
+          .join("");
+      }
+    }
+
     // Use createUIMessageStream to send both LLM text and layer events
     return createUIMessageStreamResponse({
       stream: createUIMessageStream({
@@ -157,10 +205,11 @@ export async function POST(req: Request) {
             },
           };
 
-          // Build config with the observer
+          // Build config with the observer and conversation ID
           const config = getCortexMemoryConfig(
             memorySpaceId || "quickstart-demo",
             userId || "demo-user",
+            conversationId,
             layerObserver,
           );
 
@@ -177,6 +226,38 @@ export async function POST(req: Request) {
 
           // Merge LLM stream into the UI message stream
           writer.merge(result.toUIMessageStream());
+
+          // If this is a new conversation, create it in the SDK and update the title
+          if (isNewConversation && messageText) {
+            try {
+              const cortex = getCortex();
+              const title = generateTitle(messageText);
+
+              // Create the conversation with the SDK
+              await cortex.conversations.create({
+                memorySpaceId: memorySpaceId || "quickstart-demo",
+                conversationId,
+                type: "user-agent",
+                participants: {
+                  userId: userId || "demo-user",
+                  agentId: "quickstart-assistant",
+                },
+                metadata: { title },
+              });
+
+              // Send conversation update to the client
+              writer.write({
+                type: "data-conversation-update",
+                data: {
+                  conversationId,
+                  title,
+                },
+                transient: true,
+              });
+            } catch (error) {
+              console.error("Failed to create conversation:", error);
+            }
+          }
         },
       }),
     });

package/templates/vercel-ai-quickstart/app/api/conversations/route.ts

@@ -0,0 +1,179 @@
+/**
+ * Conversations API Route
+ *
+ * GET: List conversations for a user (chat history)
+ * POST: Create a new conversation
+ * DELETE: Delete a conversation
+ */
+
+import { getCortex } from "@/lib/cortex";
+
+export async function GET(req: Request) {
+  try {
+    const { searchParams } = new URL(req.url);
+    const conversationId = searchParams.get("conversationId");
+    const userId = searchParams.get("userId");
+    const memorySpaceId = searchParams.get("memorySpaceId") || "quickstart-demo";
+
+    const cortex = getCortex();
+
+    // If conversationId is provided, fetch single conversation with messages
+    if (conversationId) {
+      const conversation = await cortex.conversations.get(conversationId, {
+        includeMessages: true,
+        messageLimit: 100,
+      });
+
+      if (!conversation) {
+        return Response.json(
+          { error: "Conversation not found" },
+          { status: 404 }
+        );
+      }
+
+      // Transform messages to the format expected by AI SDK useChat
+      const messages = (conversation.messages || []).map((msg) => ({
+        id: msg.id,
+        role: msg.role as "user" | "assistant",
+        content: msg.content,
+        createdAt: new Date(msg.timestamp),
+      }));
+
+      return Response.json({
+        conversation: {
+          id: conversation.conversationId,
+          title: (conversation.metadata?.title as string) || getDefaultTitle(conversation),
+          createdAt: conversation.createdAt,
+          updatedAt: conversation.updatedAt,
+          messageCount: conversation.messageCount || 0,
+        },
+        messages,
+      });
+    }
+
+    // List conversations for user (requires userId)
+    if (!userId) {
+      return Response.json(
+        { error: "userId is required" },
+        { status: 400 }
+      );
+    }
+
+    // Get conversations for the user
+    const result = await cortex.conversations.list({
+      memorySpaceId,
+      userId,
+      limit: 50,
+    });
+
+    // Map conversations to a simpler format for the UI
+    const conversations = result.conversations.map((conv) => ({
+      id: conv.conversationId,
+      title: (conv.metadata?.title as string) || getDefaultTitle(conv),
+      createdAt: conv.createdAt,
+      updatedAt: conv.updatedAt,
+      messageCount: conv.messageCount || 0,
+    }));
+
+    // Sort by updatedAt descending (most recent first)
+    conversations.sort((a, b) => b.updatedAt - a.updatedAt);
+
+    return Response.json({ conversations });
+  } catch (error) {
+    console.error("[Conversations Error]", error);
+
+    return Response.json(
+      { error: "Failed to fetch conversations" },
+      { status: 500 }
+    );
+  }
+}
+
+export async function POST(req: Request) {
+  try {
+    const body = await req.json();
+    const { userId, memorySpaceId = "quickstart-demo", title } = body;
+
+    if (!userId) {
+      return Response.json(
+        { error: "userId is required" },
+        { status: 400 }
+      );
+    }
+
+    const cortex = getCortex();
+
+    // Create a new conversation
+    const conversationId = `conv-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+
+    const conversation = await cortex.conversations.create({
+      memorySpaceId,
+      conversationId,
+      type: "user-agent",
+      participants: {
+        userId,
+        agentId: "quickstart-assistant",
+      },
+      metadata: {
+        title: title || "New Chat",
+      },
+    });
+
+    return Response.json({
+      success: true,
+      conversation: {
+        id: conversation.conversationId,
+        title: (conversation.metadata?.title as string) || "New Chat",
+        createdAt: conversation.createdAt,
+        updatedAt: conversation.updatedAt,
+        messageCount: 0,
+      },
+    });
+  } catch (error) {
+    console.error("[Conversation Create Error]", error);
+
+    return Response.json(
+      { error: "Failed to create conversation" },
+      { status: 500 }
+    );
+  }
+}
+
+export async function DELETE(req: Request) {
+  try {
+    const { searchParams } = new URL(req.url);
+    const conversationId = searchParams.get("conversationId");
+
+    if (!conversationId) {
+      return Response.json(
+        { error: "conversationId is required" },
+        { status: 400 }
+      );
+    }
+
+    const cortex = getCortex();
+
+    await cortex.conversations.delete(conversationId);
+
+    return Response.json({ success: true });
+  } catch (error) {
+    console.error("[Conversation Delete Error]", error);
+
+    return Response.json(
+      { error: "Failed to delete conversation" },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * Generate a default title from conversation data
+ */
+function getDefaultTitle(conv: { createdAt: number; messageCount?: number }): string {
+  const date = new Date(conv.createdAt);
+  const timeStr = date.toLocaleTimeString("en-US", {
+    hour: "numeric",
+    minute: "2-digit",
+  });
+  return `Chat at ${timeStr}`;
+}