comisai 1.0.10 → 1.0.12

package/node_modules/@comis/memory/dist/delivery-queue-adapter.test.js

@@ -1,263 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import Database from "better-sqlite3";
-import { initSchema } from "./schema.js";
-import { createSqliteDeliveryQueue } from "./delivery-queue-adapter.js";
-describe("SqliteDeliveryQueueAdapter", () => {
-    let db;
-    let queue;
-    const now = Date.now();
-    /** Helper to create a minimal enqueue input. */
-    function makeEntry(overrides = {}) {
-        return {
-            text: "Hello, world!",
-            channelType: "telegram",
-            channelId: "ch-123",
-            tenantId: "default",
-            optionsJson: "{}",
-            origin: "agent",
-            formatApplied: false,
-            chunkingApplied: false,
-            maxAttempts: 5,
-            createdAt: now,
-            scheduledAt: now,
-            expireAt: now + 3_600_000,
-            traceId: "trace-abc",
-            ...overrides,
-        };
-    }
-    beforeEach(() => {
-        db = new Database(":memory:");
-        initSchema(db, 768);
-        queue = createSqliteDeliveryQueue(db);
-    });
-    // -----------------------------------------------------------------------
-    // enqueue
-    // -----------------------------------------------------------------------
-    describe("enqueue", () => {
-        it("returns ok with a UUID string", async () => {
-            const result = await queue.enqueue(makeEntry());
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/);
-            }
-        });
-        it("increments depth to 1 after enqueue", async () => {
-            await queue.enqueue(makeEntry());
-            const depth = await queue.depth();
-            expect(depth.ok).toBe(true);
-            if (depth.ok) {
-                expect(depth.value).toBe(1);
-            }
-        });
-        it("persists all fields correctly", async () => {
-            await queue.enqueue(makeEntry({ formatApplied: true, chunkingApplied: true }));
-            const pending = await queue.pendingEntries();
-            expect(pending.ok).toBe(true);
-            if (pending.ok) {
-                const entry = pending.value[0];
-                expect(entry.text).toBe("Hello, world!");
-                expect(entry.channelType).toBe("telegram");
-                expect(entry.channelId).toBe("ch-123");
-                expect(entry.tenantId).toBe("default");
-                expect(entry.optionsJson).toBe("{}");
-                expect(entry.origin).toBe("agent");
-                expect(entry.formatApplied).toBe(true);
-                expect(entry.chunkingApplied).toBe(true);
-                expect(entry.status).toBe("pending");
-                expect(entry.attemptCount).toBe(0);
-                expect(entry.maxAttempts).toBe(5);
-                expect(entry.traceId).toBe("trace-abc");
-                expect(entry.markdownFallbackApplied).toBe(false);
-                expect(entry.deliveredMessageId).toBeNull();
-                expect(entry.lastAttemptAt).toBeNull();
-                expect(entry.nextRetryAt).toBeNull();
-                expect(entry.lastError).toBeNull();
-            }
-        });
-    });
-    // -----------------------------------------------------------------------
-    // ack
-    // -----------------------------------------------------------------------
-    describe("ack", () => {
-        it("marks entry as delivered and removes from depth count", async () => {
-            const enqResult = await queue.enqueue(makeEntry());
-            expect(enqResult.ok).toBe(true);
-            if (!enqResult.ok)
-                return;
-            const ackResult = await queue.ack(enqResult.value, "msg-telegram-42");
-            expect(ackResult.ok).toBe(true);
-            const depth = await queue.depth();
-            expect(depth.ok).toBe(true);
-            if (depth.ok) {
-                expect(depth.value).toBe(0);
-            }
-        });
-    });
-    // -----------------------------------------------------------------------
-    // nack
-    // -----------------------------------------------------------------------
-    describe("nack", () => {
-        it("increments attempt_count, sets next_retry_at and last_error", async () => {
-            const enqResult = await queue.enqueue(makeEntry());
-            expect(enqResult.ok).toBe(true);
-            if (!enqResult.ok)
-                return;
-            const retryAt = now + 60_000;
-            const nackResult = await queue.nack(enqResult.value, "timeout", retryAt);
-            expect(nackResult.ok).toBe(true);
-            // Read back the entry to verify fields
-            const row = db
-                .prepare("SELECT * FROM delivery_queue WHERE id = ?")
-                .get(enqResult.value);
-            expect(row.attempt_count).toBe(1);
-            expect(row.next_retry_at).toBe(retryAt);
-            expect(row.last_error).toBe("timeout");
-            expect(row.status).toBe("pending");
-            expect(row.last_attempt_at).toBeTypeOf("number");
-        });
-        it("keeps entry in pending state (still counted in depth)", async () => {
-            const enqResult = await queue.enqueue(makeEntry());
-            if (!enqResult.ok)
-                return;
-            await queue.nack(enqResult.value, "err", now + 60_000);
-            const depth = await queue.depth();
-            expect(depth.ok).toBe(true);
-            if (depth.ok) {
-                expect(depth.value).toBe(1);
-            }
-        });
-    });
-    // -----------------------------------------------------------------------
-    // fail
-    // -----------------------------------------------------------------------
-    describe("fail", () => {
-        it("marks entry as permanently failed and removes from depth count", async () => {
-            const enqResult = await queue.enqueue(makeEntry());
-            expect(enqResult.ok).toBe(true);
-            if (!enqResult.ok)
-                return;
-            const failResult = await queue.fail(enqResult.value, "permanent: channel not found");
-            expect(failResult.ok).toBe(true);
-            // Verify status
-            const row = db
-                .prepare("SELECT status, last_error FROM delivery_queue WHERE id = ?")
-                .get(enqResult.value);
-            expect(row.status).toBe("failed");
-            expect(row.last_error).toBe("permanent: channel not found");
-            // Depth should be 0 (failed entries excluded)
-            const depth = await queue.depth();
-            expect(depth.ok).toBe(true);
-            if (depth.ok) {
-                expect(depth.value).toBe(0);
-            }
-        });
-    });
-    // -----------------------------------------------------------------------
-    // pendingEntries
-    // -----------------------------------------------------------------------
-    describe("pendingEntries", () => {
-        it("returns only entries where scheduled_at <= now, ordered by created_at ASC", async () => {
-            // Entry 1: scheduled in the past (should appear)
-            await queue.enqueue(makeEntry({ text: "old", createdAt: now - 3000, scheduledAt: now - 2000 }));
-            // Entry 2: scheduled now (should appear)
-            await queue.enqueue(makeEntry({ text: "current", createdAt: now - 2000, scheduledAt: now }));
-            // Entry 3: scheduled in the future (should NOT appear)
-            await queue.enqueue(makeEntry({
-                text: "future",
-                createdAt: now - 1000,
-                scheduledAt: now + 60_000,
-            }));
-            const result = await queue.pendingEntries();
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value).toHaveLength(2);
-                expect(result.value[0].text).toBe("old");
-                expect(result.value[1].text).toBe("current");
-            }
-        });
-        it("excludes non-pending statuses", async () => {
-            const enqResult = await queue.enqueue(makeEntry());
-            if (!enqResult.ok)
-                return;
-            await queue.ack(enqResult.value, "msg-1");
-            const result = await queue.pendingEntries();
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value).toHaveLength(0);
-            }
-        });
-    });
-    // -----------------------------------------------------------------------
-    // pruneExpired
-    // -----------------------------------------------------------------------
-    describe("pruneExpired", () => {
-        it("removes expired non-delivered entries", async () => {
-            // Entry with expire_at in the past
-            await queue.enqueue(makeEntry({ expireAt: now - 1000 }));
-            const result = await queue.pruneExpired();
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value).toBe(1);
-            }
-            const depth = await queue.depth();
-            expect(depth.ok).toBe(true);
-            if (depth.ok) {
-                expect(depth.value).toBe(0);
-            }
-        });
-        it("does NOT prune delivered entries even if expired", async () => {
-            const enqResult = await queue.enqueue(makeEntry({ expireAt: now - 1000 }));
-            if (!enqResult.ok)
-                return;
-            // Ack it so status = delivered
-            await queue.ack(enqResult.value, "msg-1");
-            const result = await queue.pruneExpired();
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value).toBe(0);
-            }
-            // Verify the row still exists
-            const count = db
-                .prepare("SELECT COUNT(*) as c FROM delivery_queue")
-                .get();
-            expect(count.c).toBe(1);
-        });
-        it("returns 0 when nothing to prune", async () => {
-            const result = await queue.pruneExpired();
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value).toBe(0);
-            }
-        });
-    });
-    // -----------------------------------------------------------------------
-    // depth
-    // -----------------------------------------------------------------------
-    describe("depth", () => {
-        it("counts pending and in_flight entries only", async () => {
-            // 2 pending entries
-            await queue.enqueue(makeEntry({ text: "a" }));
-            await queue.enqueue(makeEntry({ text: "b" }));
-            // 1 entry acked (delivered)
-            const ackResult = await queue.enqueue(makeEntry({ text: "c" }));
-            if (ackResult.ok)
-                await queue.ack(ackResult.value, "msg-c");
-            // 1 entry failed
-            const failResult = await queue.enqueue(makeEntry({ text: "d" }));
-            if (failResult.ok)
-                await queue.fail(failResult.value, "permanent");
-            const depth = await queue.depth();
-            expect(depth.ok).toBe(true);
-            if (depth.ok) {
-                expect(depth.value).toBe(2); // only the 2 pending entries
-            }
-        });
-        it("returns 0 on empty queue", async () => {
-            const depth = await queue.depth();
-            expect(depth.ok).toBe(true);
-            if (depth.ok) {
-                expect(depth.value).toBe(0);
-            }
-        });
-    });
-});

package/node_modules/@comis/memory/dist/embedding-batch-indexer.test.d.ts

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

package/node_modules/@comis/memory/dist/embedding-batch-indexer.test.js

@@ -1,202 +0,0 @@
-import { ok, err } from "@comis/shared";
-import Database from "better-sqlite3";
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import { createBatchIndexer } from "./embedding-batch-indexer.js";
-import { initSchema } from "./schema.js";
-const DIMS = 4;
-/** Create a mock EmbeddingPort that returns deterministic vectors. */
-function createMockPort(opts) {
-    let batchCallCount = 0;
-    const failAfter = opts?.failAfterBatches ?? Infinity;
-    const embedBatchFn = vi.fn(async (texts) => {
-        batchCallCount++;
-        if (batchCallCount > failAfter) {
-            return err(new Error("provider unavailable"));
-        }
-        const vecs = texts.map((t) => {
-            const vec = new Array(DIMS).fill(0);
-            for (let i = 0; i < t.length && i < DIMS; i++) {
-                vec[i] = t.charCodeAt(i) / 256;
-            }
-            return vec;
-        });
-        return ok(vecs);
-    });
-    const port = {
-        provider: "test",
-        dimensions: DIMS,
-        modelId: "test-embed-model",
-        embed: vi.fn().mockResolvedValue(ok(new Array(DIMS).fill(0))),
-        embedBatch: embedBatchFn,
-        embedBatchFn,
-        get batchCallCount() {
-            return batchCallCount;
-        },
-    };
-    return port;
-}
-/** Insert a minimal memory row. */
-function insertMemory(db, id, content, hasEmbedding = 0) {
-    db.prepare(`INSERT INTO memories (id, tenant_id, user_id, content, trust_level, memory_type, source_who, tags, created_at, has_embedding)
-     VALUES (?, 'default', 'u1', ?, 'learned', 'semantic', 'agent', '[]', ?, ?)`).run(id, content, Date.now(), hasEmbedding);
-}
-describe("createBatchIndexer", () => {
-    let db;
-    beforeEach(() => {
-        db = new Database(":memory:");
-        initSchema(db, DIMS);
-    });
-    it("indexUnembedded embeds all unembedded memories", async () => {
-        const port = createMockPort();
-        const indexer = createBatchIndexer(db, port);
-        insertMemory(db, "m1", "hello world");
-        insertMemory(db, "m2", "goodbye world");
-        insertMemory(db, "m3", "test content");
-        const result = await indexer.indexUnembedded();
-        expect(result.indexed).toBe(3);
-        expect(result.failed).toBe(0);
-        // All should now be marked as embedded
-        const count = indexer.unembeddedCount();
-        expect(count).toBe(0);
-    });
-    it("indexUnembedded with multiple batches processes all", async () => {
-        const port = createMockPort();
-        const indexer = createBatchIndexer(db, port, { batchSize: 2 });
-        // Insert 5 memories, batchSize=2 -> 3 batches (2, 2, 1)
-        for (let i = 0; i < 5; i++) {
-            insertMemory(db, `m${i}`, `content ${i}`);
-        }
-        const result = await indexer.indexUnembedded();
-        expect(result.indexed).toBe(5);
-        expect(result.failed).toBe(0);
-        // Should have been called 3 times (batches of 2, 2, 1)
-        expect(port.embedBatchFn).toHaveBeenCalledTimes(3);
-        expect(indexer.unembeddedCount()).toBe(0);
-    });
-    it("indexUnembedded stops on embedBatch failure", async () => {
-        // Fail after the first batch
-        const port = createMockPort({ failAfterBatches: 1 });
-        const indexer = createBatchIndexer(db, port, { batchSize: 2 });
-        // Insert 4 memories -> would need 2 batches
-        for (let i = 0; i < 4; i++) {
-            insertMemory(db, `m${i}`, `content ${i}`);
-        }
-        const result = await indexer.indexUnembedded();
-        // First batch of 2 succeeded, second batch of 2 failed
-        expect(result.indexed).toBe(2);
-        expect(result.failed).toBe(2);
-        // 2 still unembedded
-        expect(indexer.unembeddedCount()).toBe(2);
-    });
-    it("reindexAll clears and re-embeds everything", async () => {
-        const port = createMockPort();
-        const indexer = createBatchIndexer(db, port);
-        // Insert memories already marked as embedded
-        insertMemory(db, "m1", "hello", 1);
-        insertMemory(db, "m2", "world", 1);
-        // Verify they start as embedded
-        expect(indexer.unembeddedCount()).toBe(0);
-        const result = await indexer.reindexAll();
-        expect(result.indexed).toBe(2);
-        expect(result.failed).toBe(0);
-        // embedBatch should have been called to re-embed
-        expect(port.embedBatchFn).toHaveBeenCalled();
-        expect(indexer.unembeddedCount()).toBe(0);
-    });
-    it("unembeddedCount returns correct count", () => {
-        const port = createMockPort();
-        const indexer = createBatchIndexer(db, port);
-        expect(indexer.unembeddedCount()).toBe(0);
-        insertMemory(db, "m1", "hello");
-        expect(indexer.unembeddedCount()).toBe(1);
-        insertMemory(db, "m2", "world");
-        expect(indexer.unembeddedCount()).toBe(2);
-        // One already embedded
-        insertMemory(db, "m3", "embedded", 1);
-        expect(indexer.unembeddedCount()).toBe(2);
-    });
-    it("indexUnembedded with no unembedded entries returns zeros", async () => {
-        const port = createMockPort();
-        const indexer = createBatchIndexer(db, port);
-        // No memories at all
-        const result = await indexer.indexUnembedded();
-        expect(result.indexed).toBe(0);
-        expect(result.failed).toBe(0);
-        // embedBatch should never be called
-        expect(port.embedBatchFn).not.toHaveBeenCalled();
-    });
-    it("indexUnembedded skips already-embedded memories", async () => {
-        const port = createMockPort();
-        const indexer = createBatchIndexer(db, port);
-        // Mix of embedded and unembedded
-        insertMemory(db, "m1", "already done", 1);
-        insertMemory(db, "m2", "needs embedding");
-        const result = await indexer.indexUnembedded();
-        expect(result.indexed).toBe(1);
-        expect(result.failed).toBe(0);
-        // Only 1 text sent to embedBatch
-        expect(port.embedBatchFn).toHaveBeenCalledTimes(1);
-        expect(port.embedBatchFn).toHaveBeenCalledWith(["needs embedding"]);
-    });
-    it("indexUnembedded handles per-item null failures gracefully", async () => {
-        // Create a port that returns null for the second item
-        const perItemFailPort = {
-            provider: "test",
-            dimensions: DIMS,
-            modelId: "test-embed-model",
-            embed: vi.fn().mockResolvedValue(ok(new Array(DIMS).fill(0))),
-            embedBatch: vi.fn(async (texts) => {
-                const vecs = texts.map((t, i) => {
-                    if (i === 1)
-                        return null; // Second item fails
-                    const vec = new Array(DIMS).fill(0);
-                    for (let j = 0; j < t.length && j < DIMS; j++) {
-                        vec[j] = t.charCodeAt(j) / 256;
-                    }
-                    return vec;
-                });
-                return ok(vecs);
-            }),
-        };
-        const indexer = createBatchIndexer(db, perItemFailPort);
-        insertMemory(db, "m1", "hello world");
-        insertMemory(db, "m2", "this one fails");
-        insertMemory(db, "m3", "test content");
-        const result = await indexer.indexUnembedded();
-        expect(result.indexed).toBe(2);
-        expect(result.failed).toBe(1);
-        // Successful ones should have has_embedding = 1
-        const m1 = db.prepare("SELECT has_embedding FROM memories WHERE id = ?").get("m1");
-        const m3 = db.prepare("SELECT has_embedding FROM memories WHERE id = ?").get("m3");
-        expect(m1.has_embedding).toBe(1);
-        expect(m3.has_embedding).toBe(1);
-        // Failed one should have has_embedding = -1 (permanently failed, not retried)
-        const m2 = db.prepare("SELECT has_embedding FROM memories WHERE id = ?").get("m2");
-        expect(m2.has_embedding).toBe(-1);
-        // No unembedded (0) left -- all are either 1 or -1
-        expect(indexer.unembeddedCount()).toBe(0);
-    });
-    it("indexUnembedded truncates oversized text before embedding", async () => {
-        // Track texts passed to embedBatch
-        let capturedTexts = [];
-        const capturingPort = {
-            provider: "test",
-            dimensions: DIMS,
-            modelId: "test-embed-model",
-            embed: vi.fn().mockResolvedValue(ok(new Array(DIMS).fill(0))),
-            embedBatch: vi.fn(async (texts) => {
-                capturedTexts = texts;
-                const vecs = texts.map(() => new Array(DIMS).fill(0));
-                return ok(vecs);
-            }),
-        };
-        const indexer = createBatchIndexer(db, capturingPort);
-        // Insert a memory with content exceeding 6144 chars (1536 tokens * 4 chars/token)
-        const oversizedContent = "x".repeat(50_000);
-        insertMemory(db, "m1", oversizedContent);
-        await indexer.indexUnembedded();
-        // The text passed to embedBatch should be truncated to 6144 chars
-        expect(capturedTexts.length).toBe(1);
-        expect(capturedTexts[0].length).toBe(6_144);
-    });
-});

package/node_modules/@comis/memory/dist/embedding-cache-lru.test.d.ts

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