@cortexmemory/cli 0.26.0 → 0.27.1

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

package/templates/vercel-ai-quickstart/lib/layer-tracking.ts

@@ -0,0 +1,214 @@
+"use client";
+
+import { useState, useCallback } from "react";
+
+// Layer types (defined locally to avoid import issues before npm install)
+export type MemoryLayer =
+  | "memorySpace"
+  | "user"
+  | "agent"
+  | "conversation"
+  | "vector"
+  | "facts"
+  | "graph";
+
+export type LayerStatus =
+  | "pending"
+  | "in_progress"
+  | "complete"
+  | "error"
+  | "skipped";
+
+/**
+ * Revision action taken by the belief revision system (v0.24.0+)
+ * - ADD: New fact was created (no conflicts)
+ * - UPDATE: Existing fact was updated with new information
+ * - SUPERSEDE: Old fact was superseded by contradicting information
+ * - NONE: No action taken (duplicate or irrelevant)
+ */
+export type RevisionAction = "ADD" | "UPDATE" | "SUPERSEDE" | "NONE";
+
+export interface LayerState {
+  status: LayerStatus;
+  latencyMs?: number;
+  data?: {
+    id?: string;
+    preview?: string;
+    metadata?: Record<string, unknown>;
+  };
+  startedAt?: number;
+  completedAt?: number;
+  /**
+   * Revision action taken (v0.24.0+)
+   * Only present for facts layer when belief revision is enabled
+   */
+  revisionAction?: RevisionAction;
+  /**
+   * Facts that were superseded by this action (v0.24.0+)
+   * Only present when revisionAction is "SUPERSEDE"
+   */
+  supersededFacts?: string[];
+}
+
+export interface LayerTrackingState {
+  layers: Record<string, LayerState>;
+  isOrchestrating: boolean;
+  orchestrationStartTime?: number;
+}
+
+const initialLayerState: LayerState = {
+  status: "pending",
+};
+
+const allLayers: MemoryLayer[] = [
+  "memorySpace",
+  "user",
+  "agent",
+  "conversation",
+  "vector",
+  "facts",
+  "graph",
+];
+
+export function useLayerTracking() {
+  const [state, setState] = useState<LayerTrackingState>({
+    layers: Object.fromEntries(
+      allLayers.map((layer) => [layer, { ...initialLayerState }]),
+    ),
+    isOrchestrating: false,
+  });
+
+  const startOrchestration = useCallback(() => {
+    const now = Date.now();
+    setState({
+      layers: Object.fromEntries(
+        allLayers.map((layer) => [
+          layer,
+          { status: "pending" as LayerStatus, startedAt: now },
+        ]),
+      ),
+      isOrchestrating: true,
+      orchestrationStartTime: now,
+    });
+  }, []);
+
+  const updateLayer = useCallback(
+    (
+      layer: MemoryLayer,
+      status: LayerStatus,
+      data?: LayerState["data"],
+      revisionInfo?: {
+        action?: RevisionAction;
+        supersededFacts?: string[];
+      },
+    ) => {
+      setState((prev: LayerTrackingState) => {
+        const now = Date.now();
+        const layerState = prev.layers[layer];
+        const latencyMs = layerState?.startedAt
+          ? now - layerState.startedAt
+          : prev.orchestrationStartTime
+            ? now - prev.orchestrationStartTime
+            : undefined;
+
+        // Check if all layers are complete
+        const updatedLayers: Record<string, LayerState> = {
+          ...prev.layers,
+          [layer]: {
+            ...layerState,
+            status,
+            latencyMs,
+            data,
+            completedAt: status === "complete" ? now : layerState?.completedAt,
+            // Belief revision info (v0.24.0+)
+            revisionAction: revisionInfo?.action,
+            supersededFacts: revisionInfo?.supersededFacts,
+          },
+        };
+
+        const isStillOrchestrating = Object.values(updatedLayers).some(
+          (l: LayerState) =>
+            l.status === "pending" || l.status === "in_progress",
+        );
+
+        return {
+          ...prev,
+          layers: updatedLayers,
+          isOrchestrating: isStillOrchestrating,
+        };
+      });
+    },
+    [],
+  );
+
+  const resetLayers = useCallback(() => {
+    setState({
+      layers: Object.fromEntries(
+        allLayers.map((layer) => [layer, { ...initialLayerState }]),
+      ),
+      isOrchestrating: false,
+    });
+  }, []);
+
+  return {
+    layers: state.layers,
+    isOrchestrating: state.isOrchestrating,
+    startOrchestration,
+    updateLayer,
+    resetLayers,
+  };
+}
+
+/**
+ * Generate sample data for layer previews (used in demos)
+ */
+export function generateSampleLayerData(
+  layer: MemoryLayer,
+  userMessage?: string,
+): LayerState["data"] {
+  switch (layer) {
+    case "memorySpace":
+      return {
+        id: "quickstart-demo",
+        preview: "Memory space for demo",
+        metadata: { isolation: "full" },
+      };
+    case "user":
+      return {
+        id: "demo-user",
+        preview: "Demo User",
+        metadata: { memories: 5 },
+      };
+    case "agent":
+      return {
+        id: "quickstart-assistant",
+        preview: "Cortex Demo Assistant",
+      };
+    case "conversation":
+      return {
+        id: `conv-${Date.now()}`,
+        preview: userMessage?.slice(0, 50) || "New conversation",
+        metadata: { messages: 2 },
+      };
+    case "vector":
+      return {
+        id: `mem-${Date.now()}`,
+        preview: "Embedded content...",
+        metadata: { dimensions: 1536, importance: 75 },
+      };
+    case "facts":
+      return {
+        id: `fact-${Date.now()}`,
+        preview: "Extracted facts from conversation",
+        metadata: { count: 3, types: ["identity", "preference"] },
+      };
+    case "graph":
+      return {
+        id: `graph-sync-${Date.now()}`,
+        preview: "Entity relationships",
+        metadata: { nodes: 4, edges: 3 },
+      };
+    default:
+      return undefined;
+  }
+}

package/templates/vercel-ai-quickstart/next.config.js

@@ -0,0 +1,7 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  transpilePackages: ["@cortexmemory/sdk", "@cortexmemory/vercel-ai-provider"],
+  serverExternalPackages: ["convex"],
+};
+
+module.exports = nextConfig;

package/templates/vercel-ai-quickstart/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@cortexmemory/vercel-ai-quickstart",
+  "version": "1.0.0",
+  "private": true,
+  "license": "UNLICENSED",
+  "description": "Cortex Memory + Vercel AI SDK Quickstart Demo",
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "lint": "next lint",
+    "convex:dev": "convex dev",
+    "convex:deploy": "convex deploy"
+  },
+  "dependencies": {
+    "@ai-sdk/openai": "^3.0.1",
+    "@ai-sdk/react": "^3.0.3",
+    "@anthropic-ai/sdk": "^0.71.2",
+    "@cortexmemory/sdk": "file:../../..",
+    "@cortexmemory/vercel-ai-provider": "file:..",
+    "ai": "^6.0.3",
+    "convex": "^1.31.2",
+    "framer-motion": "^12.23.26",
+    "neo4j-driver": "^6.0.1",
+    "next": "^16.1.1",
+    "openai": "^6.15.0",
+    "react": "^19.2.3",
+    "react-dom": "^19.2.3",
+    "zod": "^4.2.1"
+  },
+  "devDependencies": {
+    "@tailwindcss/postcss": "^4.1.18",
+    "@types/node": "^25.0.3",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
+    "autoprefixer": "^10.4.23",
+    "postcss": "^8.5.6",
+    "tailwindcss": "^4.1.18",
+    "typescript": "^5.9.3"
+  }
+}

package/templates/vercel-ai-quickstart/postcss.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+  plugins: {
+    "@tailwindcss/postcss": {},
+  },
+};

package/templates/vercel-ai-quickstart/tailwind.config.js

@@ -0,0 +1,37 @@
+/** @type {import('tailwindcss').Config} */
+module.exports = {
+  content: [
+    "./app/**/*.{js,ts,jsx,tsx,mdx}",
+    "./components/**/*.{js,ts,jsx,tsx,mdx}",
+  ],
+  theme: {
+    extend: {
+      colors: {
+        cortex: {
+          50: "#f0f7ff",
+          100: "#e0effe",
+          200: "#b9dffc",
+          300: "#7cc5fa",
+          400: "#36a8f5",
+          500: "#0c8ce6",
+          600: "#006fc4",
+          700: "#0159a0",
+          800: "#064b84",
+          900: "#0b3f6d",
+          950: "#072848",
+        },
+      },
+      animation: {
+        "pulse-slow": "pulse 3s cubic-bezier(0.4, 0, 0.6, 1) infinite",
+        flow: "flow 2s ease-in-out infinite",
+      },
+      keyframes: {
+        flow: {
+          "0%, 100%": { opacity: "0.3" },
+          "50%": { opacity: "1" },
+        },
+      },
+    },
+  },
+  plugins: [],
+};

package/templates/vercel-ai-quickstart/tsconfig.json

@@ -0,0 +1,33 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./*"]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts"
+  ],
+  "exclude": ["node_modules", "convex"]
+}