@cortexmemory/cli 0.29.0 → 0.32.0

package/templates/basic/package.json

@@ -19,20 +19,20 @@
   },
   "dependencies": {
     "@cortexmemory/sdk": "latest",
-    "convex": "^1.31.2",
+    "convex": "^1.31.5",
     "dotenv": "^17.2.3",
-    "hono": "^4.11.3",
-    "@hono/node-server": "^1.19.7"
+    "hono": "^4.11.4",
+    "@hono/node-server": "^1.19.9"
   },
   "devDependencies": {
-    "@types/node": "^25.0.3",
-    "@vitest/coverage-v8": "^4.0.16",
+    "@types/node": "^25.0.9",
+    "@vitest/coverage-v8": "^4.0.17",
     "typescript": "^5.9.3",
     "tsx": "^4.21.0",
-    "vitest": "^4.0.16"
+    "vitest": "^4.0.17"
   },
   "optionalDependencies": {
-    "openai": "^6.15.0"
+    "openai": "^6.16.0"
   },
   "engines": {
     "node": ">=20"

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

@@ -13,11 +13,11 @@
  * infrastructure is identical to ensure feature parity.
  */
 
-import { createCortexMemoryAsync } from "@cortexmemory/vercel-ai-provider";
-import type {
-  LayerObserver,
-  CortexMemoryConfig,
+import {
+  createCortexMemoryAsync,
+  createLayerStreamObserver,
 } from "@cortexmemory/vercel-ai-provider";
+import type { CortexMemoryConfig } from "@cortexmemory/vercel-ai-provider";
 import { openai, createOpenAI } from "@ai-sdk/openai";
 import {
   streamText,
@@ -52,8 +52,7 @@ function getCortexMemoryConfig(
   memorySpaceId: string,
   userId: string,
   conversationId: string,
-  layerObserver?: LayerObserver,
-): CortexMemoryConfig {
+): Omit<CortexMemoryConfig, "layerObserver"> {
   return {
     convexUrl: process.env.CONVEX_URL!,
     memorySpaceId,
@@ -103,9 +102,6 @@ function getCortexMemoryConfig(
     // Memory recall configuration
     memorySearchLimit: 20,
 
-    // Real-time layer tracking
-    layerObserver,
-
     // Debug in development
     debug: process.env.NODE_ENV === "development",
   };
@@ -233,54 +229,23 @@ export async function POST(req: Request) {
     return createUIMessageStreamResponse({
       stream: createUIMessageStream({
         execute: async ({ writer }) => {
-          // Create layer observer for real-time UI updates
-          const layerObserver: LayerObserver = {
-            onOrchestrationStart: (orchestrationId) => {
-              writer.write({
-                type: "data-orchestration-start",
-                data: { orchestrationId },
-                transient: true,
-              });
-            },
-            onLayerUpdate: (event) => {
-              writer.write({
-                type: "data-layer-update",
-                data: {
-                  layer: event.layer,
-                  status: event.status,
-                  timestamp: event.timestamp,
-                  latencyMs: event.latencyMs,
-                  data: event.data,
-                  error: event.error,
-                  revisionAction: event.revisionAction,
-                  supersededFacts: event.supersededFacts,
-                },
-                transient: true,
-              });
-            },
-            onOrchestrationComplete: (summary) => {
-              writer.write({
-                type: "data-orchestration-complete",
-                data: {
-                  orchestrationId: summary.orchestrationId,
-                  totalLatencyMs: summary.totalLatencyMs,
-                  createdIds: summary.createdIds,
-                },
-                transient: true,
-              });
-            },
-          };
+          // Create layer observer using the streaming helper
+          // This replaces ~35 lines of manual observer setup with 2 lines!
+          const { observer, emitTo } = createLayerStreamObserver();
+          emitTo(writer);
 
           // Build config with observer
           const config = getCortexMemoryConfig(
             memorySpaceId,
             userId,
             conversationId,
-            layerObserver,
           );
 
           // Create memory-augmented model - THIS handles both recall AND storage!
-          const cortexMemory = await createCortexMemoryAsync(config);
+          const cortexMemory = await createCortexMemoryAsync({
+            ...config,
+            layerObserver: observer,
+          });
 
           // Stream response with automatic memory integration
           const result = streamText({

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

@@ -1,214 +1,43 @@
 "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)
+ * Layer Tracking - Re-exports from @cortexmemory/vercel-ai-provider/react
+ *
+ * This file re-exports the layer tracking hook and utilities from the provider
+ * package, adding the "use client" directive for Next.js App Router compatibility.
+ *
+ * The provider package contains the full implementation including:
+ * - useLayerTracking() hook for state management
+ * - handleDataPart callback for automatic stream parsing
+ * - Type definitions for layers, states, and events
+ *
+ * @example
+ * ```typescript
+ * import { useLayerTracking } from '@/lib/layer-tracking';
+ * import { useChat } from '@ai-sdk/react';
+ *
+ * function ChatComponent() {
+ *   const { layers, isOrchestrating, handleDataPart } = useLayerTracking();
+ *   const { messages } = useChat({ onData: handleDataPart });
+ *   // ...
+ * }
+ * ```
  */
-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;
-  }
-}
+// Re-export everything from the provider's React module
+export {
+  useLayerTracking,
+  generateSampleLayerData,
+  ALL_LAYERS,
+} from "@cortexmemory/vercel-ai-provider/react";
+
+// Re-export types
+export type {
+  MemoryLayer,
+  LayerStatus,
+  RevisionAction,
+  LayerState,
+  LayerTrackingState,
+  LayerUpdateData,
+  UseLayerTrackingResult,
+} from "@cortexmemory/vercel-ai-provider/react";

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

@@ -19,17 +19,17 @@
     "convex:deploy": "convex deploy"
   },
   "dependencies": {
-    "@ai-sdk/openai": "^3.0.4",
-    "@ai-sdk/react": "^3.0.11",
+    "@ai-sdk/openai": "^3.0.12",
+    "@ai-sdk/react": "^3.0.44",
     "@anthropic-ai/sdk": "^0.71.2",
     "@cortexmemory/sdk": "file:../../..",
     "@cortexmemory/vercel-ai-provider": "file:..",
-    "ai": "^6.0.11",
-    "convex": "^1.31.2",
-    "framer-motion": "^12.24.0",
+    "ai": "^6.0.42",
+    "convex": "^1.31.5",
+    "framer-motion": "^12.27.1",
     "neo4j-driver": "^6.0.1",
-    "next": "^16.1.1",
-    "openai": "^6.15.0",
+    "next": "^16.1.4",
+    "openai": "^6.16.0",
     "react": "^19.2.3",
     "react-dom": "^19.2.3",
     "zod": "^4.3.5"
@@ -37,8 +37,8 @@
   "devDependencies": {
     "@tailwindcss/postcss": "^4.1.18",
     "@types/jest": "^30.0.0",
-    "@types/node": "^25.0.3",
-    "@types/react": "^19.2.7",
+    "@types/node": "^25.0.9",
+    "@types/react": "^19.2.8",
     "@types/react-dom": "^19.2.3",
     "autoprefixer": "^10.4.23",
     "jest": "^30.2.0",