@cortexmemory/cli 0.27.3 → 0.28.0

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

@@ -0,0 +1,60 @@
+/**
+ * Version detection utilities for displaying SDK versions in the UI.
+ */
+
+export interface VersionInfo {
+  cortexSdk: string;
+  aiSdk: string;
+  aiSdkMajor: number;
+}
+
+/**
+ * Detect installed SDK versions at runtime.
+ * Returns version strings for display in the UI.
+ */
+export async function detectVersions(): Promise<VersionInfo> {
+  let cortexSdk = "unknown";
+  let aiSdk = "unknown";
+  let aiSdkMajor = 5;
+
+  // Detect Cortex SDK version
+  try {
+    const cortexModule = await import("@cortexmemory/sdk");
+    // Check for version export or use package version
+    if ("VERSION" in cortexModule) {
+      cortexSdk = cortexModule.VERSION as string;
+    } else {
+      // Fallback: try to detect from package
+      cortexSdk = "0.24.0";
+    }
+  } catch {
+    cortexSdk = "0.24.0";
+  }
+
+  // Detect AI SDK version by checking for v6-specific exports
+  try {
+    const aiModule = await import("ai");
+
+    // v6 has these specific exports
+    const hasV6Features =
+      "ToolLoopAgent" in aiModule ||
+      "createAgentUIStreamResponse" in aiModule ||
+      "Output" in aiModule;
+
+    if (hasV6Features) {
+      aiSdkMajor = 6;
+      aiSdk = "v6";
+    } else {
+      aiSdkMajor = 5;
+      aiSdk = "v5";
+    }
+  } catch {
+    aiSdk = "v5";
+  }
+
+  return {
+    cortexSdk,
+    aiSdk,
+    aiSdkMajor,
+  };
+}

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

@@ -4,6 +4,11 @@ const path = require("path");
 const nextConfig = {
   transpilePackages: ["@cortexmemory/sdk", "@cortexmemory/vercel-ai-provider"],
   serverExternalPackages: ["convex"],
+  // Disable image optimization to avoid sharp dependency (LGPL licensed)
+  // This quickstart doesn't use image optimization features
+  images: {
+    unoptimized: true,
+  },
   experimental: {
     // Ensure linked packages resolve dependencies from this project's node_modules
     externalDir: true,
@@ -16,8 +21,11 @@ const nextConfig = {
   webpack: (config) => {
     config.resolve.alias = {
       ...config.resolve.alias,
-      "@anthropic-ai/sdk": path.resolve(__dirname, "node_modules/@anthropic-ai/sdk"),
-      "openai": path.resolve(__dirname, "node_modules/openai"),
+      "@anthropic-ai/sdk": path.resolve(
+        __dirname,
+        "node_modules/@anthropic-ai/sdk",
+      ),
+      openai: path.resolve(__dirname, "node_modules/openai"),
       "neo4j-driver": path.resolve(__dirname, "node_modules/neo4j-driver"),
     };
     return config;

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

@@ -5,42 +5,53 @@
   "license": "UNLICENSED",
   "description": "Cortex Memory + Vercel AI SDK Quickstart Demo",
   "scripts": {
-    "dev": "next dev --webpack",
+    "dev": "next dev --webpack -H 0.0.0.0",
     "build": "next build --webpack",
-    "start": "next start",
+    "start": "next start -H 0.0.0.0",
     "lint": "next lint",
-    "test": "jest",
+    "test": "jest --selectProjects unit integration",
+    "test:unit": "jest --selectProjects unit",
+    "test:integration": "jest --selectProjects integration",
+    "test:e2e": "jest --selectProjects e2e",
+    "test:all": "jest",
     "test:watch": "jest --watch",
     "convex:dev": "convex dev",
     "convex:deploy": "convex deploy"
   },
   "dependencies": {
-    "@ai-sdk/openai": "^3.0.1",
-    "@ai-sdk/react": "^3.0.3",
+    "@ai-sdk/openai": "^3.0.4",
+    "@ai-sdk/react": "^3.0.11",
     "@anthropic-ai/sdk": "^0.71.2",
     "@cortexmemory/sdk": "file:../../..",
     "@cortexmemory/vercel-ai-provider": "file:..",
-    "ai": "^6.0.3",
+    "ai": "^6.0.11",
     "convex": "^1.31.2",
-    "framer-motion": "^12.23.26",
+    "framer-motion": "^12.24.0",
     "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"
+    "zod": "^4.3.5"
   },
   "devDependencies": {
     "@tailwindcss/postcss": "^4.1.18",
-    "@types/jest": "^29.5.14",
+    "@types/jest": "^30.0.0",
     "@types/node": "^25.0.3",
     "@types/react": "^19.2.7",
     "@types/react-dom": "^19.2.3",
     "autoprefixer": "^10.4.23",
-    "jest": "^29.7.0",
+    "jest": "^30.2.0",
     "postcss": "^8.5.6",
     "tailwindcss": "^4.1.18",
-    "ts-jest": "^29.2.5",
+    "ts-jest": "^29.4.6",
     "typescript": "^5.9.3"
-  }
+  },
+  "main": "jest.config.js",
+  "directories": {
+    "lib": "lib",
+    "test": "tests"
+  },
+  "keywords": [],
+  "author": ""
 }

package/templates/vercel-ai-quickstart/test-api.mjs

@@ -0,0 +1,303 @@
+#!/usr/bin/env node
+/**
+ * Programmatic API Route Tests
+ * Tests both v5 and v6 routes for memory functionality
+ */
+
+const BASE_URL = process.env.QUICKSTART_URL || "http://localhost:3000";
+
+// Test configuration
+const TEST_USER_ID = `test-user-${Date.now()}`;
+const TEST_MEMORY_SPACE_ID = "quickstart-demo";
+
+async function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function testRoute(routePath, routeName) {
+  console.log(`\n${"=".repeat(60)}`);
+  console.log(`Testing ${routeName} (${routePath})`);
+  console.log("=".repeat(60));
+
+  const conversationId = `conv-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+
+  // Test 1: Send a message with a fact
+  console.log("\n📤 Test 1: Sending message with a fact...");
+  const message1 = {
+    id: `msg-${Date.now()}-1`,
+    role: "user",
+    content: `My favorite programming language is TypeScript and I work at a company called TechCorp.`,
+    createdAt: new Date().toISOString(),
+  };
+
+  try {
+    const response1 = await fetch(`${BASE_URL}${routePath}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        messages: [message1],
+        userId: TEST_USER_ID,
+        memorySpaceId: TEST_MEMORY_SPACE_ID,
+        conversationId,
+      }),
+    });
+
+    if (!response1.ok) {
+      const errorText = await response1.text();
+      console.log(`❌ Request failed with status ${response1.status}`);
+      console.log(`   Error: ${errorText.slice(0, 500)}`);
+      return {
+        success: false,
+        route: routeName,
+        error: `HTTP ${response1.status}`,
+      };
+    }
+
+    // Read streaming response
+    const reader = response1.body.getReader();
+    const decoder = new TextDecoder();
+    let fullResponse = "";
+    let chunks = 0;
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      const chunk = decoder.decode(value, { stream: true });
+      fullResponse += chunk;
+      chunks++;
+    }
+
+    console.log(
+      `✅ Response received (${chunks} chunks, ${fullResponse.length} bytes)`,
+    );
+
+    // Check for layer observer data
+    const hasLayerData =
+      fullResponse.includes("FACTS_LAYER") ||
+      fullResponse.includes("MEMORY_LAYER") ||
+      fullResponse.includes("layerId");
+    console.log(
+      `   Layer observer data: ${hasLayerData ? "✅ Present" : "❌ Missing"}`,
+    );
+
+    // Check for text content
+    const hasTextContent =
+      fullResponse.includes('"type":"text"') ||
+      fullResponse.includes("text-delta");
+    console.log(
+      `   Text content: ${hasTextContent ? "✅ Present" : "❌ Missing"}`,
+    );
+  } catch (error) {
+    console.log(`❌ Request error: ${error.message}`);
+    return { success: false, route: routeName, error: error.message };
+  }
+
+  // Wait for async processing (fact extraction, etc.)
+  console.log("\n⏳ Waiting for memory processing...");
+  await sleep(3000);
+
+  // Test 2: Check if facts were stored
+  console.log("\n🔍 Test 2: Checking stored facts...");
+  try {
+    const factsResponse = await fetch(
+      `${BASE_URL}/api/facts?userId=${TEST_USER_ID}&memorySpaceId=${TEST_MEMORY_SPACE_ID}`,
+      { method: "GET" },
+    );
+
+    if (factsResponse.ok) {
+      const factsData = await factsResponse.json();
+      const facts = factsData.facts || factsData || [];
+      console.log(
+        `✅ Facts API returned: ${Array.isArray(facts) ? facts.length : "unknown"} facts`,
+      );
+
+      if (Array.isArray(facts) && facts.length > 0) {
+        console.log("   Sample facts:");
+        facts.slice(0, 3).forEach((fact, i) => {
+          const content =
+            fact.content || fact.text || JSON.stringify(fact).slice(0, 100);
+          console.log(`     ${i + 1}. ${content.slice(0, 80)}...`);
+        });
+      }
+    } else {
+      console.log(`⚠️ Facts API returned ${factsResponse.status}`);
+    }
+  } catch (error) {
+    console.log(`⚠️ Could not check facts: ${error.message}`);
+  }
+
+  // Test 3: Send follow-up message and verify recall
+  console.log("\n📤 Test 3: Sending follow-up to test recall...");
+  const message2 = {
+    id: `msg-${Date.now()}-2`,
+    role: "user",
+    content: "What programming language do I prefer?",
+    createdAt: new Date().toISOString(),
+  };
+
+  // Include previous assistant response for context
+  const message1Response = {
+    id: `msg-${Date.now()}-1r`,
+    role: "assistant",
+    content:
+      "Great! TypeScript is a fantastic choice for type-safe development.",
+    createdAt: new Date().toISOString(),
+  };
+
+  try {
+    const response2 = await fetch(`${BASE_URL}${routePath}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        messages: [message1, message1Response, message2],
+        userId: TEST_USER_ID,
+        memorySpaceId: TEST_MEMORY_SPACE_ID,
+        conversationId,
+      }),
+    });
+
+    if (!response2.ok) {
+      console.log(
+        `❌ Follow-up request failed with status ${response2.status}`,
+      );
+      return {
+        success: false,
+        route: routeName,
+        error: `Follow-up HTTP ${response2.status}`,
+      };
+    }
+
+    const reader = response2.body.getReader();
+    const decoder = new TextDecoder();
+    let fullResponse = "";
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      fullResponse += decoder.decode(value, { stream: true });
+    }
+
+    // Check if TypeScript was mentioned in the response (recall working)
+    const mentionsTypeScript = fullResponse
+      .toLowerCase()
+      .includes("typescript");
+    console.log(`✅ Response received`);
+    console.log(
+      `   Recalls TypeScript preference: ${mentionsTypeScript ? "✅ Yes" : "❌ No"}`,
+    );
+
+    return {
+      success: true,
+      route: routeName,
+      recallWorks: mentionsTypeScript,
+    };
+  } catch (error) {
+    console.log(`❌ Follow-up request error: ${error.message}`);
+    return { success: false, route: routeName, error: error.message };
+  }
+}
+
+async function testConversationAPI() {
+  console.log(`\n${"=".repeat(60)}`);
+  console.log("Testing Conversation API");
+  console.log("=".repeat(60));
+
+  try {
+    const response = await fetch(
+      `${BASE_URL}/api/conversations?userId=${TEST_USER_ID}&memorySpaceId=${TEST_MEMORY_SPACE_ID}`,
+      { method: "GET" },
+    );
+
+    if (response.ok) {
+      const data = await response.json();
+      const conversations = data.conversations || data || [];
+      console.log(
+        `✅ Conversations API works: ${Array.isArray(conversations) ? conversations.length : "unknown"} conversations`,
+      );
+      return true;
+    } else {
+      console.log(`❌ Conversations API returned ${response.status}`);
+      return false;
+    }
+  } catch (error) {
+    console.log(`❌ Conversations API error: ${error.message}`);
+    return false;
+  }
+}
+
+async function checkServerHealth() {
+  console.log("🏥 Checking server health...");
+  try {
+    const response = await fetch(`${BASE_URL}/api/health`, {
+      method: "GET",
+      signal: AbortSignal.timeout(5000),
+    });
+    if (response.ok) {
+      console.log("✅ Server is healthy");
+      return true;
+    } else {
+      console.log(`❌ Health check failed: ${response.status}`);
+      return false;
+    }
+  } catch (error) {
+    console.log(`❌ Server not reachable: ${error.message}`);
+    return false;
+  }
+}
+
+async function main() {
+  console.log("🧪 Cortex Memory API Route Tests");
+  console.log(`📍 Testing server at: ${BASE_URL}`);
+  console.log(`👤 Test user: ${TEST_USER_ID}`);
+  console.log(`📦 Memory space: ${TEST_MEMORY_SPACE_ID}`);
+
+  // Check server health first
+  const healthy = await checkServerHealth();
+  if (!healthy) {
+    console.log(
+      "\n❌ Server is not running. Please start the quickstart first:",
+    );
+    console.log("   cd packages/vercel-ai-provider/quickstart && npm run dev");
+    process.exit(1);
+  }
+
+  const results = [];
+
+  // Test conversation API
+  await testConversationAPI();
+
+  // Test v5 route
+  const v5Result = await testRoute("/api/chat", "V5 Route");
+  results.push(v5Result);
+
+  // Test v6 route
+  const v6Result = await testRoute("/api/chat-v6", "V6 Route");
+  results.push(v6Result);
+
+  // Summary
+  console.log(`\n${"=".repeat(60)}`);
+  console.log("📊 Test Summary");
+  console.log("=".repeat(60));
+
+  let allPassed = true;
+  for (const result of results) {
+    const status = result.success ? "✅ PASS" : "❌ FAIL";
+    const recall =
+      result.recallWorks !== undefined
+        ? result.recallWorks
+          ? " (recall ✅)"
+          : " (recall ❌)"
+        : "";
+    const error = result.error ? ` - ${result.error}` : "";
+    console.log(`${status} ${result.route}${recall}${error}`);
+    if (!result.success) allPassed = false;
+  }
+
+  console.log("");
+  process.exit(allPassed ? 0 : 1);
+}
+
+main().catch((error) => {
+  console.error("Test runner error:", error);
+  process.exit(1);
+});