comisai 1.0.11 → 1.0.13

package/node_modules/@comis/memory/dist/memory-concurrency.test.js

@@ -1,222 +0,0 @@
-/**
- * AGT-06 / AGT-07: SQLite WAL memory concurrency tests.
- *
- * Validates that concurrent memory operations under SQLite WAL mode
- * with multiple SqliteMemoryAdapter connections produce no errors.
- *
- * CRITICAL: Uses file-based SQLite (NOT :memory:). :memory: databases
- * cannot be shared across connections. WAL concurrency testing requires
- * file-based DB with multiple SqliteMemoryAdapter instances.
- *
- * NOTE on better-sqlite3 synchronous behavior:
- * better-sqlite3 is synchronous -- all SQL operations execute on the main
- * thread and are naturally serialized by the Node.js event loop within a
- * single connection. Promise.all with sync operations may not actually
- * overlap within a single tick. However, these tests validate the contract:
- * concurrent calls from multiple adapter instances do not produce unhandled
- * errors under WAL mode. If SQLITE_BUSY errors appear, adding
- * `busy_timeout = 5000` pragma to SqliteMemoryAdapter would resolve them.
- */
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { SqliteMemoryAdapter } from "./sqlite-memory-adapter.js";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { randomUUID } from "node:crypto";
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-/** Create a minimal valid MemoryEntry for testing. */
-function makeEntry(overrides) {
-    return {
-        id: overrides?.id ?? randomUUID(),
-        tenantId: overrides?.tenantId ?? "default",
-        agentId: overrides?.agentId ?? "default",
-        userId: overrides?.userId ?? "user-1",
-        content: overrides?.content ?? "test memory content",
-        trustLevel: overrides?.trustLevel ?? "learned",
-        source: overrides?.source ?? { who: "agent", channel: "telegram" },
-        tags: overrides?.tags ?? [],
-        createdAt: overrides?.createdAt ?? Date.now(),
-        ...(overrides?.memoryType ? { memoryType: overrides.memoryType } : {}),
-    };
-}
-/** Remove .db, .db-wal, .db-shm files. */
-function cleanupDb(dbPath) {
-    for (const suffix of ["", "-wal", "-shm"]) {
-        try {
-            fs.unlinkSync(dbPath + suffix);
-        }
-        catch {
-            /* ignore -- file may not exist */
-        }
-    }
-}
-/** Create a WAL-enabled MemoryConfig for a given dbPath. */
-function createWalConfig(dbPath) {
-    return {
-        dbPath,
-        walMode: true,
-        embeddingModel: "test",
-        embeddingDimensions: 4,
-        compaction: { enabled: false, threshold: 1000, targetSize: 500 },
-        retention: { maxAgeDays: 0, maxEntries: 0 },
-    };
-}
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-describe("WAL concurrency tests", () => {
-    let dbPath;
-    const adapters = [];
-    const sessionKey = {
-        tenantId: "default",
-        userId: "user-1",
-        channelId: "ch-1",
-    };
-    beforeEach(() => {
-        dbPath = path.join(os.tmpdir(), `wal-test-${randomUUID()}.db`);
-    });
-    afterEach(() => {
-        // Close all adapters (some may already be closed)
-        for (const adapter of adapters) {
-            try {
-                adapter.close();
-            }
-            catch {
-                /* already closed */
-            }
-        }
-        adapters.length = 0;
-        cleanupDb(dbPath);
-    });
-    // ── AGT-06: Concurrent store() and search() under WAL ──────────────
-    describe("AGT-06 — Concurrent store() and search() under WAL", () => {
-        it("concurrent store and search from different adapters produce no errors", async () => {
-            const config = createWalConfig(dbPath);
-            const adapter1 = new SqliteMemoryAdapter(config);
-            adapters.push(adapter1);
-            const adapter2 = new SqliteMemoryAdapter(config);
-            adapters.push(adapter2);
-            // Verify WAL is active
-            const journalMode = adapter1
-                .getDb()
-                .pragma("journal_mode", { simple: true });
-            expect(journalMode).toBe("wal");
-            // Seed some data via adapter1 so search has results to find
-            const e1 = makeEntry({ id: "e1", content: "seed entry one" });
-            const e2 = makeEntry({ id: "e2", content: "seed entry two" });
-            const e3 = makeEntry({ id: "e3", content: "seed entry three" });
-            await adapter1.store(e1);
-            await adapter1.store(e2);
-            await adapter1.store(e3);
-            // Fire concurrent operations from both adapters
-            const results = await Promise.all([
-                adapter1.store(makeEntry({ id: "e4", content: "concurrent entry four" })),
-                adapter2.store(makeEntry({ id: "e5", content: "concurrent entry five" })),
-                adapter1.search(sessionKey, "concurrent"),
-                adapter2.search(sessionKey, "entry"),
-            ]);
-            // All 4 results should succeed
-            for (let i = 0; i < results.length; i++) {
-                if (!results[i].ok) {
-                    const errResult = results[i];
-                    console.error(`Result ${i} failed:`, errResult.error.message);
-                }
-                expect(results[i].ok).toBe(true);
-            }
-        });
-        it("interleaved store-then-search across adapters returns stored data", async () => {
-            const config = createWalConfig(dbPath);
-            const adapter1 = new SqliteMemoryAdapter(config);
-            adapters.push(adapter1);
-            const adapter2 = new SqliteMemoryAdapter(config);
-            adapters.push(adapter2);
-            // adapter1 stores "alpha data"
-            const storeResult1 = await adapter1.store(makeEntry({ id: "alpha-1", content: "alpha data" }));
-            expect(storeResult1.ok).toBe(true);
-            // adapter2 searches for "alpha" -- should find it (WAL readers see committed writes)
-            const searchResult1 = await adapter2.search(sessionKey, "alpha");
-            expect(searchResult1.ok).toBe(true);
-            if (searchResult1.ok) {
-                expect(searchResult1.value.length).toBeGreaterThanOrEqual(1);
-                expect(searchResult1.value[0].entry.content).toBe("alpha data");
-            }
-            // adapter2 stores "beta data"
-            const storeResult2 = await adapter2.store(makeEntry({ id: "beta-1", content: "beta data" }));
-            expect(storeResult2.ok).toBe(true);
-            // adapter1 searches for "beta" -- should find it
-            const searchResult2 = await adapter1.search(sessionKey, "beta");
-            expect(searchResult2.ok).toBe(true);
-            if (searchResult2.ok) {
-                expect(searchResult2.value.length).toBeGreaterThanOrEqual(1);
-                expect(searchResult2.value[0].entry.content).toBe("beta data");
-            }
-        });
-    });
-    // ── AGT-07: Concurrent store() calls with no SQLITE_BUSY ───────────
-    describe("AGT-07 — Concurrent store() calls with no SQLITE_BUSY", () => {
-        it("multiple concurrent store calls from different connections succeed", async () => {
-            const config = createWalConfig(dbPath);
-            const adapter1 = new SqliteMemoryAdapter(config);
-            adapters.push(adapter1);
-            const adapter2 = new SqliteMemoryAdapter(config);
-            adapters.push(adapter2);
-            // Fire 10 concurrent store calls alternating between adapters
-            const promises = [];
-            for (let i = 0; i < 10; i++) {
-                const adapter = i % 2 === 0 ? adapter1 : adapter2;
-                promises.push(adapter.store(makeEntry({ id: `concurrent-${i}`, content: `entry ${i}` })));
-            }
-            const results = await Promise.all(promises);
-            // ALL results should have ok === true (no SQLITE_BUSY errors)
-            for (let i = 0; i < results.length; i++) {
-                if (!results[i].ok) {
-                    const errResult = results[i];
-                    console.error(`Store ${i} failed with SQLITE_BUSY or other error:`, errResult.error.message);
-                }
-                expect(results[i].ok).toBe(true);
-            }
-            // Verify data integrity: retrieve each of the 10 entries
-            for (let i = 0; i < 10; i++) {
-                const retrieved = await adapter1.retrieve(`concurrent-${i}`);
-                expect(retrieved.ok).toBe(true);
-                if (retrieved.ok) {
-                    expect(retrieved.value).toBeDefined();
-                    expect(retrieved.value.content).toBe(`entry ${i}`);
-                }
-            }
-        });
-        it("high-volume concurrent stores (20 entries) from 3 adapters", async () => {
-            const config = createWalConfig(dbPath);
-            const adapter1 = new SqliteMemoryAdapter(config);
-            adapters.push(adapter1);
-            const adapter2 = new SqliteMemoryAdapter(config);
-            adapters.push(adapter2);
-            const adapter3 = new SqliteMemoryAdapter(config);
-            adapters.push(adapter3);
-            const allAdapters = [adapter1, adapter2, adapter3];
-            // Fire 20 stores distributed across 3 adapters (round-robin)
-            const promises = [];
-            for (let i = 0; i < 20; i++) {
-                const adapter = allAdapters[i % 3];
-                promises.push(adapter.store(makeEntry({ id: `vol-${i}`, content: `volume entry ${i}` })));
-            }
-            const results = await Promise.all(promises);
-            // All 20 should succeed
-            for (let i = 0; i < results.length; i++) {
-                if (!results[i].ok) {
-                    const errResult = results[i];
-                    console.error(`High-volume store ${i} failed:`, errResult.error.message);
-                }
-                expect(results[i].ok).toBe(true);
-            }
-            // Verify: count of entries in DB matches 20
-            const row = adapter1
-                .getDb()
-                .prepare("SELECT COUNT(*) as count FROM memories")
-                .get();
-            expect(row.count).toBe(20);
-        });
-    });
-});

package/node_modules/@comis/memory/dist/named-graph-store.test.d.ts

@@ -1 +0,0 @@
-export {};

package/node_modules/@comis/memory/dist/named-graph-store.test.js

@@ -1,227 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import Database from "better-sqlite3";
-import { createNamedGraphStore } from "./named-graph-store.js";
-describe("NamedGraphStore", () => {
-    let db;
-    let store;
-    beforeEach(() => {
-        db = new Database(":memory:");
-        store = createNamedGraphStore(db);
-    });
-    describe("save and load", () => {
-        it("persists and retrieves a graph with all fields", () => {
-            const nodes = [{ id: "n1", task: "summarize" }, { id: "n2", task: "review" }];
-            const edges = [{ from: "n1", to: "n2" }];
-            const settings = { onFailure: "halt" };
-            const id = store.save({
-                id: "g1",
-                tenantId: "t1",
-                agentId: "agent-a",
-                label: "My Pipeline",
-                nodes,
-                edges,
-                settings,
-            });
-            expect(id).toBe("g1");
-            const loaded = store.load("g1", "t1");
-            expect(loaded).toBeDefined();
-            expect(loaded.id).toBe("g1");
-            expect(loaded.tenantId).toBe("t1");
-            expect(loaded.agentId).toBe("agent-a");
-            expect(loaded.label).toBe("My Pipeline");
-            expect(loaded.nodes).toEqual(nodes);
-            expect(loaded.edges).toEqual(edges);
-            expect(loaded.settings).toEqual(settings);
-            expect(loaded.createdAt).toBeGreaterThan(0);
-            expect(loaded.updatedAt).toBeGreaterThan(0);
-        });
-        it("returns undefined for non-existent id", () => {
-            expect(store.load("nonexistent", "t1")).toBeUndefined();
-        });
-        it("returns undefined for wrong tenant", () => {
-            store.save({
-                id: "g1",
-                tenantId: "t1",
-                agentId: "agent-a",
-                label: "Test",
-                nodes: [],
-                edges: [],
-                settings: {},
-            });
-            expect(store.load("g1", "t2")).toBeUndefined();
-        });
-    });
-    describe("save upsert", () => {
-        it("updates label and data on conflict", () => {
-            store.save({
-                id: "g1",
-                tenantId: "t1",
-                agentId: "agent-a",
-                label: "Original",
-                nodes: [{ id: "n1" }],
-                edges: [],
-                settings: {},
-            });
-            store.save({
-                id: "g1",
-                tenantId: "t1",
-                agentId: "agent-a",
-                label: "Updated",
-                nodes: [{ id: "n1" }, { id: "n2" }],
-                edges: [{ from: "n1", to: "n2" }],
-                settings: { mode: "strict" },
-            });
-            const loaded = store.load("g1", "t1");
-            expect(loaded).toBeDefined();
-            expect(loaded.label).toBe("Updated");
-            expect(loaded.nodes).toHaveLength(2);
-            expect(loaded.edges).toHaveLength(1);
-            expect(loaded.settings).toEqual({ mode: "strict" });
-        });
-    });
-    describe("list with pagination", () => {
-        beforeEach(() => {
-            for (let i = 1; i <= 3; i++) {
-                store.save({
-                    id: `g${i}`,
-                    tenantId: "t1",
-                    agentId: "agent-a",
-                    label: `Pipeline ${i}`,
-                    nodes: Array.from({ length: i }, (_, j) => ({ id: `n${j}` })),
-                    edges: [],
-                    settings: {},
-                });
-            }
-        });
-        it("returns paginated results with total", () => {
-            const result = store.list("t1", { limit: 2, offset: 0 });
-            expect(result.entries).toHaveLength(2);
-            expect(result.total).toBe(3);
-        });
-        it("respects offset", () => {
-            const result = store.list("t1", { limit: 2, offset: 2 });
-            expect(result.entries).toHaveLength(1);
-            expect(result.total).toBe(3);
-        });
-        it("uses default limit and offset", () => {
-            const result = store.list("t1");
-            expect(result.entries).toHaveLength(3);
-            expect(result.total).toBe(3);
-        });
-    });
-    describe("list returns summaries", () => {
-        it("includes id, label, nodeCount, createdAt, updatedAt", () => {
-            store.save({
-                id: "g1",
-                tenantId: "t1",
-                agentId: "agent-a",
-                label: "Summary Test",
-                nodes: [{ id: "n1" }, { id: "n2" }, { id: "n3" }],
-                edges: [],
-                settings: {},
-            });
-            const result = store.list("t1");
-            expect(result.entries).toHaveLength(1);
-            const summary = result.entries[0];
-            expect(summary.id).toBe("g1");
-            expect(summary.label).toBe("Summary Test");
-            expect(summary.nodeCount).toBe(3);
-            expect(summary.createdAt).toBeGreaterThan(0);
-            expect(summary.updatedAt).toBeGreaterThan(0);
-            // Summaries should NOT contain full nodes/edges/settings
-            expect(summary["nodes"]).toBeUndefined();
-            expect(summary["edges"]).toBeUndefined();
-            expect(summary["settings"]).toBeUndefined();
-        });
-    });
-    describe("softDelete", () => {
-        it("makes graph invisible to load and list", () => {
-            store.save({
-                id: "g1",
-                tenantId: "t1",
-                agentId: "agent-a",
-                label: "To Delete",
-                nodes: [],
-                edges: [],
-                settings: {},
-            });
-            const deleted = store.softDelete("g1", "t1");
-            expect(deleted).toBe(true);
-            expect(store.load("g1", "t1")).toBeUndefined();
-            const result = store.list("t1");
-            expect(result.entries).toHaveLength(0);
-            expect(result.total).toBe(0);
-        });
-        it("returns false for non-existent graph", () => {
-            expect(store.softDelete("nonexistent", "t1")).toBe(false);
-        });
-        it("returns false for already deleted graph", () => {
-            store.save({
-                id: "g1",
-                tenantId: "t1",
-                agentId: "agent-a",
-                label: "Test",
-                nodes: [],
-                edges: [],
-                settings: {},
-            });
-            expect(store.softDelete("g1", "t1")).toBe(true);
-            expect(store.softDelete("g1", "t1")).toBe(false);
-        });
-    });
-    describe("tenant isolation", () => {
-        it("scopes list results by tenant", () => {
-            store.save({
-                id: "g1",
-                tenantId: "tenant-a",
-                agentId: "agent-a",
-                label: "Tenant A Pipeline",
-                nodes: [{ id: "n1" }],
-                edges: [],
-                settings: {},
-            });
-            store.save({
-                id: "g2",
-                tenantId: "tenant-b",
-                agentId: "agent-a",
-                label: "Tenant B Pipeline",
-                nodes: [{ id: "n1" }],
-                edges: [],
-                settings: {},
-            });
-            const resultA = store.list("tenant-a");
-            expect(resultA.entries).toHaveLength(1);
-            expect(resultA.entries[0].label).toBe("Tenant A Pipeline");
-            const resultB = store.list("tenant-b");
-            expect(resultB.entries).toHaveLength(1);
-            expect(resultB.entries[0].label).toBe("Tenant B Pipeline");
-        });
-    });
-    describe("corrupt JSON resilience", () => {
-        it("returns fallback values for invalid JSON in columns", () => {
-            // Manually insert a row with corrupt JSON
-            db.prepare(`
-        INSERT INTO named_graphs (id, tenant_id, agent_id, label, nodes, edges, settings, created_at, updated_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `).run("corrupt", "t1", "agent-a", "Corrupt Graph", "NOT_JSON", "{bad", "null_like", Date.now(), Date.now());
-            const loaded = store.load("corrupt", "t1");
-            expect(loaded).toBeDefined();
-            expect(loaded.id).toBe("corrupt");
-            expect(loaded.label).toBe("Corrupt Graph");
-            // Fallback: invalid JSON -> empty array for nodes/edges
-            expect(loaded.nodes).toEqual([]);
-            expect(loaded.edges).toEqual([]);
-            // "null_like" is not valid JSON, should fallback to {}
-            expect(loaded.settings).toEqual({});
-        });
-        it("returns 0 nodeCount for corrupt JSON in list", () => {
-            db.prepare(`
-        INSERT INTO named_graphs (id, tenant_id, agent_id, label, nodes, edges, settings, created_at, updated_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `).run("corrupt2", "t1", "agent-a", "Bad Nodes", "NOT_ARRAY", "[]", "{}", Date.now(), Date.now());
-            const result = store.list("t1");
-            expect(result.entries).toHaveLength(1);
-            expect(result.entries[0].nodeCount).toBe(0);
-        });
-    });
-});

package/node_modules/@comis/memory/dist/observability-store.test.d.ts

@@ -1 +0,0 @@
-export {};