@cortexmemory/cli 0.27.1 → 0.27.4

package/templates/vercel-ai-quickstart/tests/helpers/mock-cortex.ts

@@ -0,0 +1,263 @@
+/**
+ * Mock Cortex SDK
+ *
+ * Provides a mock implementation of the Cortex SDK for testing.
+ * Simulates the SDK behavior without requiring a real Convex backend.
+ */
+
+// In-memory stores for test state
+let mutableStore: Map<string, Map<string, unknown>> = new Map();
+let usersStore: Map<string, { userId: string; data: Record<string, unknown> }> =
+  new Map();
+interface StoredConversation {
+  conversationId: string;
+  memorySpaceId: string;
+  type: string;
+  participants: { userId?: string; agentId?: string };
+  metadata: Record<string, unknown>;
+  createdAt: number;
+  updatedAt: number;
+  messageCount: number;
+  messages?: Array<{
+    id: string;
+    role: string;
+    content: string;
+    timestamp: number;
+  }>;
+}
+
+let conversationsStore: Map<string, StoredConversation> = new Map();
+
+/**
+ * Reset all mock stores (call in beforeEach)
+ */
+export function resetMockStores(): void {
+  mutableStore = new Map();
+  usersStore = new Map();
+  conversationsStore = new Map();
+}
+
+/**
+ * Create a mock Cortex SDK instance
+ */
+export function createMockCortex() {
+  return {
+    mutable: {
+      get: jest.fn(
+        async (namespace: string, key: string): Promise<unknown | null> => {
+          const ns = mutableStore.get(namespace);
+          if (!ns) return null;
+          return ns.get(key) ?? null;
+        }
+      ),
+      set: jest.fn(
+        async (
+          namespace: string,
+          key: string,
+          value: unknown
+        ): Promise<void> => {
+          if (!mutableStore.has(namespace)) {
+            mutableStore.set(namespace, new Map());
+          }
+          mutableStore.get(namespace)!.set(key, value);
+        }
+      ),
+      delete: jest.fn(
+        async (namespace: string, key: string): Promise<void> => {
+          const ns = mutableStore.get(namespace);
+          if (ns) ns.delete(key);
+        }
+      ),
+    },
+    users: {
+      get: jest.fn(
+        async (
+          userId: string
+        ): Promise<{
+          userId: string;
+          data: Record<string, unknown>;
+        } | null> => {
+          return usersStore.get(userId) ?? null;
+        }
+      ),
+      update: jest.fn(
+        async (
+          userId: string,
+          data: Record<string, unknown>
+        ): Promise<{ userId: string; data: Record<string, unknown> }> => {
+          const existing = usersStore.get(userId);
+          const user = {
+            userId,
+            data: { ...(existing?.data || {}), ...data },
+          };
+          usersStore.set(userId, user);
+          return user;
+        }
+      ),
+      delete: jest.fn(async (userId: string): Promise<void> => {
+        usersStore.delete(userId);
+      }),
+      list: jest.fn(async () => {
+        return {
+          users: Array.from(usersStore.values()),
+          hasMore: false,
+        };
+      }),
+    },
+    conversations: {
+      list: jest.fn(
+        async (params: { memorySpaceId?: string; userId?: string }) => {
+          const conversations = Array.from(conversationsStore.values()).filter(
+            (conv) => {
+              if (
+                params.memorySpaceId &&
+                conv.memorySpaceId !== params.memorySpaceId
+              ) {
+                return false;
+              }
+              if (
+                params.userId &&
+                conv.participants.userId !== params.userId
+              ) {
+                return false;
+              }
+              return true;
+            }
+          );
+          return { conversations, hasMore: false };
+        }
+      ),
+      create: jest.fn(
+        async (params: {
+          memorySpaceId: string;
+          conversationId: string;
+          type: string;
+          participants: { userId?: string; agentId?: string };
+          metadata?: Record<string, unknown>;
+        }) => {
+          const now = Date.now();
+          const conversation = {
+            conversationId: params.conversationId,
+            memorySpaceId: params.memorySpaceId,
+            type: params.type,
+            participants: params.participants,
+            metadata: params.metadata || {},
+            createdAt: now,
+            updatedAt: now,
+            messageCount: 0,
+          };
+          conversationsStore.set(params.conversationId, conversation);
+          return conversation;
+        }
+      ),
+      get: jest.fn(async (conversationId: string, options?: { includeMessages?: boolean; messageLimit?: number }) => {
+        const conv = conversationsStore.get(conversationId);
+        if (!conv) return null;
+        
+        // If includeMessages is requested, return with messages
+        if (options?.includeMessages) {
+          return {
+            ...conv,
+            messages: conv.messages || [],
+          };
+        }
+        
+        // Otherwise return without messages
+        const { messages: _messages, ...convWithoutMessages } = conv;
+        return convWithoutMessages;
+      }),
+      delete: jest.fn(async (conversationId: string): Promise<void> => {
+        conversationsStore.delete(conversationId);
+      }),
+      update: jest.fn(
+        async (
+          conversationId: string,
+          updates: { metadata?: Record<string, unknown> }
+        ) => {
+          const conv = conversationsStore.get(conversationId);
+          if (!conv) throw new Error("Conversation not found");
+          const updated = {
+            ...conv,
+            metadata: { ...conv.metadata, ...updates.metadata },
+            updatedAt: Date.now(),
+          };
+          conversationsStore.set(conversationId, updated);
+          return updated;
+        }
+      ),
+    },
+    memory: {
+      search: jest.fn().mockResolvedValue([]),
+      remember: jest.fn().mockResolvedValue({
+        conversation: { conversationId: "conv-1", messageIds: [] },
+        memories: [],
+        facts: [],
+      }),
+      recall: jest.fn().mockResolvedValue({
+        context: "",
+        totalResults: 0,
+        queryTimeMs: 10,
+        sources: { vector: { count: 0, items: [] } },
+      }),
+    },
+    close: jest.fn(),
+  };
+}
+
+/**
+ * Type for the mock Cortex instance
+ */
+export type MockCortex = ReturnType<typeof createMockCortex>;
+
+/**
+ * Helper to seed test data into stores
+ */
+export const seedTestData = {
+  user: (
+    userId: string,
+    data: Record<string, unknown> = {}
+  ): { userId: string; data: Record<string, unknown> } => {
+    const user = { userId, data };
+    usersStore.set(userId, user);
+    return user;
+  },
+  mutable: (namespace: string, key: string, value: unknown): void => {
+    if (!mutableStore.has(namespace)) {
+      mutableStore.set(namespace, new Map());
+    }
+    mutableStore.get(namespace)!.set(key, value);
+  },
+  conversation: (
+    conversationId: string,
+    params: {
+      memorySpaceId?: string;
+      userId?: string;
+      title?: string;
+      messages?: Array<{ role: string; content: string }>;
+    } = {}
+  ) => {
+    const now = Date.now();
+    const messages = params.messages?.map((msg, i) => ({
+      id: `msg-${i}`,
+      role: msg.role,
+      content: msg.content,
+      timestamp: now + i,
+    }));
+    const conversation: StoredConversation = {
+      conversationId,
+      memorySpaceId: params.memorySpaceId || "quickstart-demo",
+      type: "user-agent",
+      participants: {
+        userId: params.userId || "test-user",
+        agentId: "quickstart-assistant",
+      },
+      metadata: { title: params.title || "Test Chat" },
+      createdAt: now,
+      updatedAt: now,
+      messageCount: messages?.length || 0,
+      messages,
+    };
+    conversationsStore.set(conversationId, conversation);
+    return conversation;
+  },
+};

package/templates/vercel-ai-quickstart/tests/helpers/setup.ts

@@ -0,0 +1,48 @@
+/**
+ * Jest Test Setup
+ *
+ * Configures global test environment for quickstart tests.
+ */
+
+import { TextEncoder, TextDecoder } from "util";
+
+// Polyfill TextEncoder/TextDecoder for Node.js environment
+global.TextEncoder = TextEncoder;
+global.TextDecoder = TextDecoder as typeof global.TextDecoder;
+
+// Polyfill crypto for Node.js environment (required for password utilities)
+if (typeof global.crypto === "undefined") {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const { webcrypto } = require("crypto");
+  global.crypto = webcrypto;
+}
+
+// Polyfill btoa/atob for Node.js environment
+if (typeof global.btoa === "undefined") {
+  global.btoa = (str: string) => Buffer.from(str, "binary").toString("base64");
+}
+
+if (typeof global.atob === "undefined") {
+  global.atob = (str: string) => Buffer.from(str, "base64").toString("binary");
+}
+
+// Set test environment variables
+process.env.NODE_ENV = "test";
+process.env.CONVEX_URL = "https://test.convex.cloud";
+
+// Suppress console output during tests (optional - comment out for debugging)
+// global.console = {
+//   ...console,
+//   log: jest.fn(),
+//   debug: jest.fn(),
+//   info: jest.fn(),
+//   warn: jest.fn(),
+// };
+
+// Increase test timeout for async operations
+jest.setTimeout(10000);
+
+// Reset mocks between tests
+beforeEach(() => {
+  jest.clearAllMocks();
+});