@cortexmemory/cli 0.26.2 → 0.27.1

package/templates/vercel-ai-quickstart/components/MemorySpaceSwitcher.tsx

@@ -0,0 +1,93 @@
+"use client";
+
+import { useState } from "react";
+import { motion, AnimatePresence } from "framer-motion";
+
+interface MemorySpaceSwitcherProps {
+  value: string;
+  onChange: (value: string) => void;
+}
+
+const spaces = [
+  { id: "quickstart-demo", name: "Demo", icon: "🧪" },
+  { id: "personal", name: "Personal", icon: "👤" },
+  { id: "work", name: "Work", icon: "💼" },
+];
+
+export function MemorySpaceSwitcher({
+  value,
+  onChange,
+}: MemorySpaceSwitcherProps) {
+  const [isOpen, setIsOpen] = useState(false);
+  const currentSpace = spaces.find((s) => s.id === value) || spaces[0];
+
+  return (
+    <div className="relative">
+      <button
+        onClick={() => setIsOpen(!isOpen)}
+        className="flex items-center gap-2 px-3 py-2 bg-white/5 hover:bg-white/10 border border-white/10 rounded-lg transition-colors"
+      >
+        <span>{currentSpace.icon}</span>
+        <span className="text-sm font-medium">{currentSpace.name}</span>
+        <motion.span
+          className="text-gray-400 text-xs"
+          animate={{ rotate: isOpen ? 180 : 0 }}
+        >
+          ▼
+        </motion.span>
+      </button>
+
+      <AnimatePresence>
+        {isOpen && (
+          <>
+            {/* Backdrop */}
+            <div
+              className="fixed inset-0 z-10"
+              onClick={() => setIsOpen(false)}
+            />
+
+            {/* Dropdown */}
+            <motion.div
+              initial={{ opacity: 0, y: -10 }}
+              animate={{ opacity: 1, y: 0 }}
+              exit={{ opacity: 0, y: -10 }}
+              className="absolute right-0 top-full mt-2 w-56 bg-gray-900 border border-white/10 rounded-lg shadow-xl z-20 overflow-hidden"
+            >
+              <div className="p-2">
+                <div className="text-xs text-gray-500 px-2 py-1 mb-1">
+                  Memory Space
+                </div>
+
+                {spaces.map((space) => (
+                  <button
+                    key={space.id}
+                    onClick={() => {
+                      onChange(space.id);
+                      setIsOpen(false);
+                    }}
+                    className={`w-full flex items-center gap-2 px-3 py-2 rounded-lg text-left transition-colors ${
+                      value === space.id
+                        ? "bg-cortex-600/20 text-cortex-400"
+                        : "hover:bg-white/5"
+                    }`}
+                  >
+                    <span>{space.icon}</span>
+                    <span className="flex-1 font-medium">{space.name}</span>
+                    <code className="text-xs text-gray-500">{space.id}</code>
+                  </button>
+                ))}
+              </div>
+
+              <div className="border-t border-white/10 p-3 bg-white/5">
+                <p className="text-xs text-gray-400">
+                  Switch memory spaces to demonstrate multi-tenant isolation.
+                  Memories in one space don't appear in others.
+                </p>
+              </div>
+            </motion.div>
+          </>
+        )}
+      </AnimatePresence>
+    </div>
+  );
+}

package/templates/vercel-ai-quickstart/convex/conversations.ts

@@ -0,0 +1,67 @@
+/**
+ * Convex queries for real-time conversation updates
+ *
+ * These queries enable the LayerFlowDiagram to show live updates
+ * as data flows through the Cortex memory system.
+ */
+
+import { query } from "./_generated/server";
+import { v } from "convex/values";
+
+/**
+ * Get recent conversations for a memory space
+ *
+ * Used by the demo to watch for new conversations being created.
+ */
+export const getRecent = query({
+  args: {
+    memorySpaceId: v.string(),
+    limit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const limit = args.limit ?? 10;
+
+    // Query conversations table (from Cortex SDK schema)
+    const conversations = await ctx.db
+      .query("conversations")
+      .filter((q) => q.eq(q.field("memorySpaceId"), args.memorySpaceId))
+      .order("desc")
+      .take(limit);
+
+    return conversations;
+  },
+});
+
+/**
+ * Get a specific conversation by ID
+ */
+export const get = query({
+  args: {
+    conversationId: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const conversation = await ctx.db
+      .query("conversations")
+      .filter((q) => q.eq(q.field("conversationId"), args.conversationId))
+      .first();
+
+    return conversation;
+  },
+});
+
+/**
+ * Get conversation count for a memory space
+ */
+export const count = query({
+  args: {
+    memorySpaceId: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const conversations = await ctx.db
+      .query("conversations")
+      .filter((q) => q.eq(q.field("memorySpaceId"), args.memorySpaceId))
+      .collect();
+
+    return conversations.length;
+  },
+});

package/templates/vercel-ai-quickstart/convex/facts.ts

@@ -0,0 +1,131 @@
+/**
+ * Convex queries for real-time fact updates
+ *
+ * These queries enable the LayerFlowDiagram to show live updates
+ * as facts are extracted from conversations.
+ */
+
+import { query } from "./_generated/server";
+import { v } from "convex/values";
+
+/**
+ * Get recent facts for a memory space
+ *
+ * Used by the demo to watch for new facts being extracted.
+ */
+export const getRecent = query({
+  args: {
+    memorySpaceId: v.string(),
+    limit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const limit = args.limit ?? 20;
+
+    // Query facts table (from Cortex SDK schema)
+    const facts = await ctx.db
+      .query("facts")
+      .filter((q) => q.eq(q.field("memorySpaceId"), args.memorySpaceId))
+      .order("desc")
+      .take(limit);
+
+    return facts;
+  },
+});
+
+/**
+ * Get facts for a specific user
+ */
+export const getByUser = query({
+  args: {
+    memorySpaceId: v.string(),
+    userId: v.string(),
+    limit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const limit = args.limit ?? 50;
+
+    const facts = await ctx.db
+      .query("facts")
+      .filter((q) =>
+        q.and(
+          q.eq(q.field("memorySpaceId"), args.memorySpaceId),
+          q.eq(q.field("userId"), args.userId),
+        ),
+      )
+      .order("desc")
+      .take(limit);
+
+    return facts;
+  },
+});
+
+/**
+ * Get facts by type
+ */
+export const getByType = query({
+  args: {
+    memorySpaceId: v.string(),
+    factType: v.string(),
+    limit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const limit = args.limit ?? 20;
+
+    const facts = await ctx.db
+      .query("facts")
+      .filter((q) =>
+        q.and(
+          q.eq(q.field("memorySpaceId"), args.memorySpaceId),
+          q.eq(q.field("factType"), args.factType),
+        ),
+      )
+      .order("desc")
+      .take(limit);
+
+    return facts;
+  },
+});
+
+/**
+ * Get fact count for a memory space
+ */
+export const count = query({
+  args: {
+    memorySpaceId: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const facts = await ctx.db
+      .query("facts")
+      .filter((q) => q.eq(q.field("memorySpaceId"), args.memorySpaceId))
+      .collect();
+
+    return facts.length;
+  },
+});
+
+/**
+ * Get fact type summary for a user
+ */
+export const typeSummary = query({
+  args: {
+    memorySpaceId: v.string(),
+    userId: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    let factsQuery = ctx.db
+      .query("facts")
+      .filter((q) => q.eq(q.field("memorySpaceId"), args.memorySpaceId));
+
+    const facts = await factsQuery.collect();
+
+    // Group by type
+    const summary: Record<string, number> = {};
+    for (const fact of facts) {
+      if (args.userId && fact.userId !== args.userId) continue;
+      const type = fact.factType || "unknown";
+      summary[type] = (summary[type] || 0) + 1;
+    }
+
+    return summary;
+  },
+});

package/templates/vercel-ai-quickstart/convex/health.ts

@@ -0,0 +1,15 @@
+import { query } from "./_generated/server";
+
+/**
+ * Simple health check query to verify Convex backend is reachable
+ */
+export const ping = query({
+  args: {},
+  handler: async () => {
+    return {
+      status: "ok",
+      timestamp: Date.now(),
+      backend: "convex",
+    };
+  },
+});

package/templates/vercel-ai-quickstart/convex/memories.ts

@@ -0,0 +1,104 @@
+/**
+ * Convex queries for real-time memory updates
+ *
+ * These queries enable the LayerFlowDiagram to show live updates
+ * as vector memories are created in the Cortex system.
+ */
+
+import { query } from "./_generated/server";
+import { v } from "convex/values";
+
+/**
+ * Get recent memories for a memory space
+ *
+ * Used by the demo to watch for new memories being created.
+ */
+export const getRecent = query({
+  args: {
+    memorySpaceId: v.string(),
+    limit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const limit = args.limit ?? 10;
+
+    // Query memories table (from Cortex SDK schema)
+    const memories = await ctx.db
+      .query("memories")
+      .filter((q) => q.eq(q.field("memorySpaceId"), args.memorySpaceId))
+      .order("desc")
+      .take(limit);
+
+    return memories;
+  },
+});
+
+/**
+ * Get memories for a specific user
+ */
+export const getByUser = query({
+  args: {
+    memorySpaceId: v.string(),
+    userId: v.string(),
+    limit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const limit = args.limit ?? 20;
+
+    const memories = await ctx.db
+      .query("memories")
+      .filter((q) =>
+        q.and(
+          q.eq(q.field("memorySpaceId"), args.memorySpaceId),
+          q.eq(q.field("userId"), args.userId),
+        ),
+      )
+      .order("desc")
+      .take(limit);
+
+    return memories;
+  },
+});
+
+/**
+ * Get memory count for a memory space
+ */
+export const count = query({
+  args: {
+    memorySpaceId: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const memories = await ctx.db
+      .query("memories")
+      .filter((q) => q.eq(q.field("memorySpaceId"), args.memorySpaceId))
+      .collect();
+
+    return memories.length;
+  },
+});
+
+/**
+ * Search memories by content (simple text search for demo)
+ */
+export const search = query({
+  args: {
+    memorySpaceId: v.string(),
+    query: v.string(),
+    limit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const limit = args.limit ?? 5;
+    const queryLower = args.query.toLowerCase();
+
+    // Simple text search (in production, use vector search)
+    const allMemories = await ctx.db
+      .query("memories")
+      .filter((q) => q.eq(q.field("memorySpaceId"), args.memorySpaceId))
+      .collect();
+
+    const matching = allMemories
+      .filter((m) => m.content?.toLowerCase().includes(queryLower))
+      .slice(0, limit);
+
+    return matching;
+  },
+});

package/templates/vercel-ai-quickstart/convex/schema.ts

@@ -0,0 +1,20 @@
+/**
+ * Convex schema for the quickstart demo
+ *
+ * This extends the Cortex SDK schema to add any demo-specific tables.
+ * The actual memory tables (conversations, memories, facts) come from @cortexmemory/sdk.
+ */
+
+import { defineSchema, defineTable } from "convex/server";
+import { v } from "convex/values";
+
+export default defineSchema({
+  // Demo session tracking (optional, for demo purposes)
+  demoSessions: defineTable({
+    sessionId: v.string(),
+    userId: v.string(),
+    memorySpaceId: v.string(),
+    startedAt: v.number(),
+    messageCount: v.number(),
+  }).index("by_session", ["sessionId"]),
+});

package/templates/vercel-ai-quickstart/convex/users.ts

@@ -0,0 +1,105 @@
+/**
+ * Convex queries for user profile data
+ *
+ * These queries enable the LayerFlowDiagram to show user context
+ * during memory orchestration.
+ */
+
+import { query } from "./_generated/server";
+import { v } from "convex/values";
+
+/**
+ * Get user profile by ID
+ *
+ * Returns user information stored in the Cortex system.
+ */
+export const get = query({
+  args: {
+    userId: v.string(),
+    memorySpaceId: v.string(),
+  },
+  handler: async (ctx, args) => {
+    // Query users table (from Cortex SDK schema)
+    const user = await ctx.db
+      .query("users")
+      .filter((q) =>
+        q.and(
+          q.eq(q.field("userId"), args.userId),
+          q.eq(q.field("memorySpaceId"), args.memorySpaceId),
+        ),
+      )
+      .first();
+
+    return user;
+  },
+});
+
+/**
+ * Get users in a memory space
+ */
+export const list = query({
+  args: {
+    memorySpaceId: v.string(),
+    limit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const limit = args.limit ?? 20;
+
+    const users = await ctx.db
+      .query("users")
+      .filter((q) => q.eq(q.field("memorySpaceId"), args.memorySpaceId))
+      .take(limit);
+
+    return users;
+  },
+});
+
+/**
+ * Get user stats (memory count, fact count, etc.)
+ */
+export const stats = query({
+  args: {
+    userId: v.string(),
+    memorySpaceId: v.string(),
+  },
+  handler: async (ctx, args) => {
+    // Count memories
+    const memories = await ctx.db
+      .query("memories")
+      .filter((q) =>
+        q.and(
+          q.eq(q.field("userId"), args.userId),
+          q.eq(q.field("memorySpaceId"), args.memorySpaceId),
+        ),
+      )
+      .collect();
+
+    // Count facts
+    const facts = await ctx.db
+      .query("facts")
+      .filter((q) =>
+        q.and(
+          q.eq(q.field("userId"), args.userId),
+          q.eq(q.field("memorySpaceId"), args.memorySpaceId),
+        ),
+      )
+      .collect();
+
+    // Count conversations
+    const conversations = await ctx.db
+      .query("conversations")
+      .filter((q) =>
+        q.and(
+          q.eq(q.field("userId"), args.userId),
+          q.eq(q.field("memorySpaceId"), args.memorySpaceId),
+        ),
+      )
+      .collect();
+
+    return {
+      memoryCount: memories.length,
+      factCount: facts.length,
+      conversationCount: conversations.length,
+    };
+  },
+});

package/templates/vercel-ai-quickstart/lib/animations.ts

@@ -0,0 +1,146 @@
+import type { Variants } from "framer-motion";
+
+/**
+ * Framer Motion animation variants for the layer flow visualization
+ */
+
+// Layer card entrance animation
+export const layerCardVariants: Variants = {
+  hidden: {
+    opacity: 0,
+    x: -20,
+    scale: 0.95,
+  },
+  visible: (i: number) => ({
+    opacity: 1,
+    x: 0,
+    scale: 1,
+    transition: {
+      delay: i * 0.1,
+      duration: 0.3,
+      ease: "easeOut",
+    },
+  }),
+  exit: {
+    opacity: 0,
+    x: 20,
+    transition: {
+      duration: 0.2,
+    },
+  },
+};
+
+// Status indicator pulse animation
+export const statusPulseVariants: Variants = {
+  pending: {
+    scale: 1,
+    opacity: 0.5,
+  },
+  processing: {
+    scale: [1, 1.2, 1],
+    opacity: [0.5, 1, 0.5],
+    transition: {
+      duration: 1,
+      repeat: Infinity,
+      ease: "easeInOut",
+    },
+  },
+  complete: {
+    scale: [1, 1.3, 1],
+    opacity: 1,
+    transition: {
+      duration: 0.3,
+      ease: "easeOut",
+    },
+  },
+};
+
+// Flow line animation
+export const flowLineVariants: Variants = {
+  idle: {
+    opacity: 0.2,
+    pathLength: 0,
+  },
+  flowing: {
+    opacity: [0.2, 1, 0.2],
+    pathLength: [0, 1, 0],
+    transition: {
+      duration: 1.5,
+      repeat: Infinity,
+      ease: "easeInOut",
+    },
+  },
+  complete: {
+    opacity: 1,
+    pathLength: 1,
+  },
+};
+
+// Data preview expand animation
+export const dataPreviewVariants: Variants = {
+  collapsed: {
+    height: 0,
+    opacity: 0,
+  },
+  expanded: {
+    height: "auto",
+    opacity: 1,
+    transition: {
+      height: {
+        duration: 0.3,
+        ease: "easeOut",
+      },
+      opacity: {
+        duration: 0.2,
+        delay: 0.1,
+      },
+    },
+  },
+};
+
+// Message animation
+export const messageVariants: Variants = {
+  hidden: {
+    opacity: 0,
+    y: 10,
+    scale: 0.95,
+  },
+  visible: {
+    opacity: 1,
+    y: 0,
+    scale: 1,
+    transition: {
+      duration: 0.2,
+      ease: "easeOut",
+    },
+  },
+};
+
+// Stagger children animation
+export const staggerContainerVariants: Variants = {
+  hidden: { opacity: 0 },
+  visible: {
+    opacity: 1,
+    transition: {
+      staggerChildren: 0.1,
+      delayChildren: 0.2,
+    },
+  },
+};
+
+// Glow effect animation (for completed layers)
+export const glowVariants: Variants = {
+  idle: {
+    boxShadow: "0 0 0 0 rgba(34, 197, 94, 0)",
+  },
+  glow: {
+    boxShadow: [
+      "0 0 0 0 rgba(34, 197, 94, 0.4)",
+      "0 0 0 10px rgba(34, 197, 94, 0)",
+    ],
+    transition: {
+      duration: 0.6,
+      ease: "easeOut",
+    },
+  },
+};