@cortexmemory/cli 0.26.0 → 0.27.1

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

@@ -0,0 +1,195 @@
+"use client";
+
+import { motion } from "framer-motion";
+import { LayerCard } from "./LayerCard";
+import type { LayerState } from "@/lib/layer-tracking";
+
+interface LayerFlowDiagramProps {
+  layers: Record<string, LayerState>;
+  isOrchestrating: boolean;
+  memorySpaceId: string;
+  userId: string;
+}
+
+export function LayerFlowDiagram({
+  layers,
+  isOrchestrating,
+  memorySpaceId,
+  userId,
+}: LayerFlowDiagramProps) {
+  // Define the layer flow order
+  const topLayers = [
+    { key: "memorySpace", name: "Memory Space", icon: "📦" },
+    { key: "user", name: "User", icon: "👤" },
+    { key: "agent", name: "Agent", icon: "🤖" },
+  ];
+
+  const flowLayers = [
+    { key: "conversation", name: "Conversation", icon: "💬" },
+    { key: "vector", name: "Vector Store", icon: "🎯" },
+    { key: "facts", name: "Facts", icon: "💡" },
+    { key: "graph", name: "Graph", icon: "🕸️", optional: true },
+  ];
+
+  return (
+    <div className="space-y-6">
+      {/* Title section */}
+      <div className="text-center">
+        <h3 className="text-lg font-semibold">Memory Orchestration Flow</h3>
+        <p className="text-sm text-gray-400 mt-1">
+          {isOrchestrating
+            ? "Processing your message through Cortex layers..."
+            : "Send a message to see data flow through the system"}
+        </p>
+      </div>
+
+      {/* Top row: Context layers */}
+      <div className="flex justify-center gap-3">
+        {topLayers.map((layer, i) => (
+          <motion.div
+            key={layer.key}
+            initial={{ opacity: 0, y: -10 }}
+            animate={{ opacity: 1, y: 0 }}
+            transition={{ delay: i * 0.1 }}
+          >
+            <LayerCard
+              name={layer.name}
+              icon={layer.icon}
+              status={layers[layer.key]?.status || "pending"}
+              latencyMs={layers[layer.key]?.latencyMs}
+              data={layers[layer.key]?.data}
+              compact
+            />
+          </motion.div>
+        ))}
+      </div>
+
+      {/* Flow connector */}
+      <div className="flex justify-center">
+        <motion.div
+          className="w-0.5 h-8 bg-gradient-to-b from-white/30 to-white/10"
+          animate={{
+            opacity: isOrchestrating ? [0.3, 1, 0.3] : 0.3,
+          }}
+          transition={{
+            duration: 1.5,
+            repeat: Infinity,
+            ease: "easeInOut",
+          }}
+        />
+      </div>
+
+      {/* Main flow: Processing layers */}
+      <div className="space-y-3">
+        {flowLayers.map((layer, i) => (
+          <motion.div
+            key={layer.key}
+            initial={{ opacity: 0, x: -20 }}
+            animate={{ opacity: 1, x: 0 }}
+            transition={{ delay: 0.3 + i * 0.1 }}
+          >
+            <LayerCard
+              name={layer.name}
+              icon={layer.icon}
+              status={
+                layers[layer.key]?.status ||
+                (layer.optional ? "skipped" : "pending")
+              }
+              latencyMs={layers[layer.key]?.latencyMs}
+              data={layers[layer.key]?.data}
+              optional={layer.optional}
+              // Belief revision info (v0.24.0+) - only for facts layer
+              revisionAction={
+                layer.key === "facts"
+                  ? layers[layer.key]?.revisionAction
+                  : undefined
+              }
+              supersededFacts={
+                layer.key === "facts"
+                  ? layers[layer.key]?.supersededFacts
+                  : undefined
+              }
+            />
+
+            {/* Flow connector between layers */}
+            {i < flowLayers.length - 1 && (
+              <div className="flex justify-center py-2">
+                <motion.div
+                  className="w-0.5 h-6"
+                  style={{
+                    background:
+                      layers[layer.key]?.status === "complete"
+                        ? "linear-gradient(to bottom, rgb(34, 197, 94), rgba(255, 255, 255, 0.1))"
+                        : "linear-gradient(to bottom, rgba(255, 255, 255, 0.2), rgba(255, 255, 255, 0.05))",
+                  }}
+                  animate={{
+                    opacity:
+                      isOrchestrating &&
+                      layers[layer.key]?.status === "in_progress"
+                        ? [0.3, 1, 0.3]
+                        : 1,
+                  }}
+                  transition={{
+                    duration: 0.8,
+                    repeat: Infinity,
+                    ease: "easeInOut",
+                  }}
+                />
+              </div>
+            )}
+          </motion.div>
+        ))}
+      </div>
+
+      {/* Legend */}
+      <div className="pt-4 border-t border-white/10 space-y-2">
+        {/* Status legend */}
+        <div className="flex justify-center gap-4 text-xs text-gray-500">
+          <div className="flex items-center gap-1.5">
+            <span className="w-2 h-2 rounded-full bg-gray-500" />
+            <span>Pending</span>
+          </div>
+          <div className="flex items-center gap-1.5">
+            <span className="w-2 h-2 rounded-full bg-yellow-500 animate-pulse" />
+            <span>Processing</span>
+          </div>
+          <div className="flex items-center gap-1.5">
+            <span className="w-2 h-2 rounded-full bg-green-500" />
+            <span>Complete</span>
+          </div>
+          <div className="flex items-center gap-1.5">
+            <span className="w-2 h-2 rounded-full bg-gray-700" />
+            <span>Skipped</span>
+          </div>
+        </div>
+        {/* Belief revision legend (v0.24.0+) */}
+        <div className="flex justify-center gap-3 text-xs text-gray-600">
+          <span className="text-gray-700">Belief Revision:</span>
+          <div className="flex items-center gap-1">
+            <span className="px-1 py-0.5 bg-green-500/20 text-green-400 rounded text-[9px]">
+              NEW
+            </span>
+          </div>
+          <div className="flex items-center gap-1">
+            <span className="px-1 py-0.5 bg-blue-500/20 text-blue-400 rounded text-[9px]">
+              UPDATED
+            </span>
+          </div>
+          <div className="flex items-center gap-1">
+            <span className="px-1 py-0.5 bg-orange-500/20 text-orange-400 rounded text-[9px]">
+              SUPERSEDED
+            </span>
+          </div>
+        </div>
+      </div>
+
+      {/* Context info */}
+      <div className="text-center text-xs text-gray-600">
+        <p>
+          Space: <code className="text-gray-400">{memorySpaceId}</code> • User:{" "}
+          <code className="text-gray-400">{userId}</code>
+        </p>
+      </div>
+    </div>
+  );
+}

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"]),
+});