comisai 1.0.11 → 1.0.13

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

@@ -1,213 +0,0 @@
-import { ok, err } from "@comis/shared";
-import { describe, it, expect, vi } from "vitest";
-import { createCachedEmbeddingPort } from "./embedding-cache.js";
-const DIMS = 4;
-/** Create a mock EmbeddingPort with vi.fn() methods for call tracking. */
-function createMockPort() {
-    const embedFn = vi.fn(async (text) => {
-        const vec = new Array(DIMS).fill(0);
-        for (let i = 0; i < text.length && i < DIMS; i++) {
-            vec[i] = text.charCodeAt(i) / 256;
-        }
-        return ok(vec);
-    });
-    const embedBatchFn = vi.fn(async (texts) => {
-        const vecs = [];
-        for (const t of texts) {
-            const vec = new Array(DIMS).fill(0);
-            for (let i = 0; i < t.length && i < DIMS; i++) {
-                vec[i] = t.charCodeAt(i) / 256;
-            }
-            vecs.push(vec);
-        }
-        return ok(vecs);
-    });
-    return {
-        provider: "test",
-        dimensions: DIMS,
-        modelId: "test-model",
-        embed: embedFn,
-        embedBatch: embedBatchFn,
-        embedFn,
-        embedBatchFn,
-    };
-}
-describe("createCachedEmbeddingPort", () => {
-    it("first embed call hits inner, second returns from cache", async () => {
-        const mock = createMockPort();
-        const cached = createCachedEmbeddingPort(mock, { maxEntries: 100 });
-        const r1 = await cached.embed("hello");
-        expect(r1.ok).toBe(true);
-        expect(mock.embedFn).toHaveBeenCalledTimes(1);
-        const r2 = await cached.embed("hello");
-        expect(r2.ok).toBe(true);
-        // Inner should NOT be called again
-        expect(mock.embedFn).toHaveBeenCalledTimes(1);
-        // Both results should be identical
-        if (r1.ok && r2.ok) {
-            expect(r1.value).toEqual(r2.value);
-        }
-    });
-    it("embedBatch with mix of cached and uncached only sends misses to inner", async () => {
-        const mock = createMockPort();
-        const cached = createCachedEmbeddingPort(mock, { maxEntries: 100 });
-        // Pre-cache "alpha" via single embed
-        await cached.embed("alpha");
-        expect(mock.embedFn).toHaveBeenCalledTimes(1);
-        // Now embedBatch with alpha (cached) + beta (uncached) + gamma (uncached)
-        const result = await cached.embedBatch(["alpha", "beta", "gamma"]);
-        expect(result.ok).toBe(true);
-        // Inner embedBatch should only receive the uncached texts
-        expect(mock.embedBatchFn).toHaveBeenCalledTimes(1);
-        expect(mock.embedBatchFn).toHaveBeenCalledWith(["beta", "gamma"]);
-        // Result should have 3 vectors
-        if (result.ok) {
-            expect(result.value).toHaveLength(3);
-        }
-    });
-    it("embedBatch with all cached returns immediately without calling inner", async () => {
-        const mock = createMockPort();
-        const cached = createCachedEmbeddingPort(mock, { maxEntries: 100 });
-        // Pre-cache all texts via single embeds
-        await cached.embed("one");
-        await cached.embed("two");
-        mock.embedFn.mockClear();
-        mock.embedBatchFn.mockClear();
-        const result = await cached.embedBatch(["one", "two"]);
-        expect(result.ok).toBe(true);
-        // Neither embed nor embedBatch should be called
-        expect(mock.embedFn).not.toHaveBeenCalled();
-        expect(mock.embedBatchFn).not.toHaveBeenCalled();
-        if (result.ok) {
-            expect(result.value).toHaveLength(2);
-        }
-    });
-    it("cache respects maxEntries (oldest evicted)", async () => {
-        const mock = createMockPort();
-        const cached = createCachedEmbeddingPort(mock, { maxEntries: 2 });
-        // Fill cache to max
-        await cached.embed("first");
-        await cached.embed("second");
-        expect(mock.embedFn).toHaveBeenCalledTimes(2);
-        // Add a third entry, which should evict "first"
-        await cached.embed("third");
-        expect(mock.embedFn).toHaveBeenCalledTimes(3);
-        // "second" and "third" should be cached
-        mock.embedFn.mockClear();
-        await cached.embed("second");
-        await cached.embed("third");
-        expect(mock.embedFn).not.toHaveBeenCalled();
-        // "first" should have been evicted -- must call inner again
-        await cached.embed("first");
-        expect(mock.embedFn).toHaveBeenCalledTimes(1);
-    });
-    it("embed error is not cached", async () => {
-        const mock = createMockPort();
-        // Make first call fail
-        mock.embedFn.mockResolvedValueOnce(err(new Error("provider down")));
-        const cached = createCachedEmbeddingPort(mock, { maxEntries: 100 });
-        const r1 = await cached.embed("failing");
-        expect(r1.ok).toBe(false);
-        expect(mock.embedFn).toHaveBeenCalledTimes(1);
-        // Now make inner succeed
-        mock.embedFn.mockResolvedValueOnce(ok([1, 2, 3, 4]));
-        const r2 = await cached.embed("failing");
-        expect(r2.ok).toBe(true);
-        // Inner should be called again since error was not cached
-        expect(mock.embedFn).toHaveBeenCalledTimes(2);
-    });
-    it("preserves dimensions and modelId from inner port", () => {
-        const mock = createMockPort();
-        const cached = createCachedEmbeddingPort(mock, { maxEntries: 100 });
-        expect(cached.dimensions).toBe(DIMS);
-        expect(cached.modelId).toBe("test-model");
-    });
-    it("embedBatch propagates inner error", async () => {
-        const mock = createMockPort();
-        mock.embedBatchFn.mockResolvedValueOnce(err(new Error("batch failure")));
-        const cached = createCachedEmbeddingPort(mock, { maxEntries: 100 });
-        const result = await cached.embedBatch(["a", "b"]);
-        expect(result.ok).toBe(false);
-        if (!result.ok) {
-            expect(result.error.message).toBe("batch failure");
-        }
-    });
-    describe("getCacheStats", () => {
-        it("returns zeroed stats on fresh cache", () => {
-            const mock = createMockPort();
-            const cached = createCachedEmbeddingPort(mock, { maxEntries: 100 });
-            const stats = cached.getCacheStats();
-            expect(stats).toEqual({
-                entries: 0,
-                maxEntries: 100,
-                hitRate: 0,
-                hits: 0,
-                misses: 0,
-                provider: "test",
-            });
-        });
-        it("tracks miss on first embed and hit on second", async () => {
-            const mock = createMockPort();
-            const cached = createCachedEmbeddingPort(mock, { maxEntries: 100 });
-            await cached.embed("hello");
-            let stats = cached.getCacheStats();
-            expect(stats.misses).toBe(1);
-            expect(stats.hits).toBe(0);
-            expect(stats.entries).toBe(1);
-            await cached.embed("hello");
-            stats = cached.getCacheStats();
-            expect(stats.hits).toBe(1);
-            expect(stats.misses).toBe(1);
-            expect(stats.hitRate).toBe(0.5);
-            expect(stats.entries).toBe(1);
-        });
-        it("tracks hits and misses in embedBatch", async () => {
-            const mock = createMockPort();
-            const cached = createCachedEmbeddingPort(mock, { maxEntries: 100 });
-            // Pre-cache "alpha"
-            await cached.embed("alpha");
-            // stats: 1 miss, 0 hits
-            // embedBatch with alpha (hit) + beta (miss) + gamma (miss)
-            await cached.embedBatch(["alpha", "beta", "gamma"]);
-            const stats = cached.getCacheStats();
-            // embed: 1 miss
-            // embedBatch: 1 hit + 2 misses
-            expect(stats.hits).toBe(1);
-            expect(stats.misses).toBe(3);
-            expect(stats.entries).toBe(3);
-            expect(stats.hitRate).toBe(1 / 4);
-        });
-    });
-    describe("TTL support", () => {
-        it("expires entries after ttlMs", async () => {
-            const mock = createMockPort();
-            const cached = createCachedEmbeddingPort(mock, {
-                maxEntries: 100,
-                ttlMs: 100,
-            });
-            // First call -- inner called
-            await cached.embed("hello");
-            expect(mock.embedFn).toHaveBeenCalledTimes(1);
-            // Immediate second call -- cache hit, inner NOT called
-            await cached.embed("hello");
-            expect(mock.embedFn).toHaveBeenCalledTimes(1);
-            // Wait for TTL to expire
-            await new Promise((r) => setTimeout(r, 150));
-            // After TTL -- inner called again
-            await cached.embed("hello");
-            expect(mock.embedFn).toHaveBeenCalledTimes(2);
-        });
-        it("entries persist without TTL (LRU only)", async () => {
-            const mock = createMockPort();
-            const cached = createCachedEmbeddingPort(mock, { maxEntries: 100 });
-            // First call -- inner called
-            await cached.embed("hello");
-            expect(mock.embedFn).toHaveBeenCalledTimes(1);
-            // Wait longer than the TTL test above
-            await new Promise((r) => setTimeout(r, 200));
-            // Still cached -- inner NOT called (no TTL, pure LRU)
-            await cached.embed("hello");
-            expect(mock.embedFn).toHaveBeenCalledTimes(1);
-        });
-    });
-});

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

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

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

@@ -1,87 +0,0 @@
-import { ok } from "@comis/shared";
-import Database from "better-sqlite3";
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import { createFingerprintManager } from "./embedding-fingerprint.js";
-/** Create a minimal mock EmbeddingPort with given modelId and dimensions. */
-function stubProvider(modelId, dimensions) {
-    return {
-        provider: "test",
-        modelId,
-        dimensions,
-        embed: vi.fn().mockResolvedValue(ok(new Array(dimensions).fill(0))),
-        embedBatch: vi.fn().mockResolvedValue(ok([])),
-    };
-}
-describe("createFingerprintManager", () => {
-    let db;
-    beforeEach(() => {
-        db = new Database(":memory:");
-        const mgr = createFingerprintManager(db);
-        mgr.ensureTable();
-    });
-    it("getCurrent returns null before any save", () => {
-        const mgr = createFingerprintManager(db);
-        expect(mgr.getCurrent()).toBeNull();
-    });
-    it("getCurrent returns saved fingerprint after save", () => {
-        const mgr = createFingerprintManager(db);
-        const provider = stubProvider("text-embedding-3-small", 1536);
-        const fp = mgr.computeFingerprint(provider);
-        mgr.save(fp);
-        const stored = mgr.getCurrent();
-        expect(stored).not.toBeNull();
-        expect(stored.modelId).toBe("text-embedding-3-small");
-        expect(stored.dimensions).toBe(1536);
-        expect(stored.hash).toBe(fp.hash);
-    });
-    it("first run: hasChanged returns false (no stored fingerprint)", () => {
-        const mgr = createFingerprintManager(db);
-        const provider = stubProvider("text-embedding-3-small", 1536);
-        // No fingerprint saved yet
-        expect(mgr.hasChanged(provider)).toBe(false);
-    });
-    it("same provider: hasChanged returns false after save", () => {
-        const mgr = createFingerprintManager(db);
-        const provider = stubProvider("text-embedding-3-small", 1536);
-        mgr.save(mgr.computeFingerprint(provider));
-        expect(mgr.hasChanged(provider)).toBe(false);
-    });
-    it("changed model: hasChanged returns true", () => {
-        const mgr = createFingerprintManager(db);
-        const providerA = stubProvider("model-a", 768);
-        const providerB = stubProvider("model-b", 768);
-        mgr.save(mgr.computeFingerprint(providerA));
-        expect(mgr.hasChanged(providerB)).toBe(true);
-    });
-    it("changed dimensions: hasChanged returns true", () => {
-        const mgr = createFingerprintManager(db);
-        const provider768 = stubProvider("text-embedding-3-small", 768);
-        const provider1536 = stubProvider("text-embedding-3-small", 1536);
-        mgr.save(mgr.computeFingerprint(provider768));
-        expect(mgr.hasChanged(provider1536)).toBe(true);
-    });
-    it("computeFingerprint produces deterministic hash", () => {
-        const mgr = createFingerprintManager(db);
-        const provider = stubProvider("nomic-embed-text", 384);
-        const fp1 = mgr.computeFingerprint(provider);
-        const fp2 = mgr.computeFingerprint(provider);
-        expect(fp1.hash).toBe(fp2.hash);
-        expect(fp1.modelId).toBe("nomic-embed-text");
-        expect(fp1.dimensions).toBe(384);
-    });
-    it("save overwrites previous fingerprint", () => {
-        const mgr = createFingerprintManager(db);
-        const providerA = stubProvider("model-a", 768);
-        const providerB = stubProvider("model-b", 1536);
-        mgr.save(mgr.computeFingerprint(providerA));
-        expect(mgr.getCurrent().modelId).toBe("model-a");
-        mgr.save(mgr.computeFingerprint(providerB));
-        expect(mgr.getCurrent().modelId).toBe("model-b");
-        expect(mgr.getCurrent().dimensions).toBe(1536);
-    });
-    it("ensureTable is idempotent (safe to call multiple times)", () => {
-        const mgr = createFingerprintManager(db);
-        // Already called once in beforeEach; calling again should not throw
-        expect(() => mgr.ensureTable()).not.toThrow();
-    });
-});

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

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

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

@@ -1,31 +0,0 @@
-import { createHash } from "node:crypto";
-import { describe, it, expect } from "vitest";
-import { computeEmbeddingIdentityHash } from "./embedding-hash.js";
-describe("computeEmbeddingIdentityHash", () => {
-    it("produces SHA-256 of modelId:dimensions", () => {
-        const expected = createHash("sha256")
-            .update("text-embedding-3-small:1536")
-            .digest("hex");
-        expect(computeEmbeddingIdentityHash("text-embedding-3-small", 1536)).toBe(expected);
-    });
-    it("returns full 64-char hex (no truncation)", () => {
-        const hash = computeEmbeddingIdentityHash("any-model", 768);
-        expect(hash).toHaveLength(64);
-        expect(hash).toMatch(/^[0-9a-f]{64}$/);
-    });
-    it("is deterministic (same input = same output)", () => {
-        const a = computeEmbeddingIdentityHash("nomic-embed-text", 384);
-        const b = computeEmbeddingIdentityHash("nomic-embed-text", 384);
-        expect(a).toBe(b);
-    });
-    it("differs when modelId differs", () => {
-        const a = computeEmbeddingIdentityHash("model-a", 768);
-        const b = computeEmbeddingIdentityHash("model-b", 768);
-        expect(a).not.toBe(b);
-    });
-    it("differs when dimensions differ", () => {
-        const a = computeEmbeddingIdentityHash("text-embedding-3-small", 768);
-        const b = computeEmbeddingIdentityHash("text-embedding-3-small", 1536);
-        expect(a).not.toBe(b);
-    });
-});

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

@@ -1,8 +0,0 @@
-/**
- * Integration tests for the full embedding pipeline.
- *
- * Exercises the end-to-end flow: config -> provider creation -> cache wrapping ->
- * fingerprint check -> batch indexing -> queue wiring -> memory adapter with vector
- * search. Uses mock EmbeddingPort (no actual node-llama-cpp or OpenAI calls).
- */
-export {};

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

@@ -1,232 +0,0 @@
-/**
- * Integration tests for the full embedding pipeline.
- *
- * Exercises the end-to-end flow: config -> provider creation -> cache wrapping ->
- * fingerprint check -> batch indexing -> queue wiring -> memory adapter with vector
- * search. Uses mock EmbeddingPort (no actual node-llama-cpp or OpenAI calls).
- */
-import { ok, err } from "@comis/shared";
-import Database from "better-sqlite3";
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { initSchema, isVecAvailable } from "./schema.js";
-import { SqliteMemoryAdapter } from "./sqlite-memory-adapter.js";
-import { createCachedEmbeddingPort } from "./embedding-cache-lru.js";
-import { createFingerprintManager } from "./embedding-fingerprint.js";
-import { createBatchIndexer } from "./embedding-batch-indexer.js";
-import { createEmbeddingQueue } from "./embedding-queue.js";
-const DIMS = 4;
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-/**
- * Create a mock EmbeddingPort with deterministic fake vectors.
- * Vectors are based on character codes for uniqueness per input text.
- */
-function createMockEmbeddingPort(dimensions = DIMS, modelId = "test-model") {
-    const embedFn = vi.fn(async (text) => {
-        const vec = new Array(dimensions).fill(0.1);
-        for (let i = 0; i < text.length && i < dimensions; i++) {
-            vec[i] = text.charCodeAt(i) / 256;
-        }
-        return ok(vec);
-    });
-    const embedBatchFn = vi.fn(async (texts) => {
-        const vecs = texts.map((t) => {
-            const vec = new Array(dimensions).fill(0.1);
-            for (let i = 0; i < t.length && i < dimensions; i++) {
-                vec[i] = t.charCodeAt(i) / 256;
-            }
-            return vec;
-        });
-        return ok(vecs);
-    });
-    return {
-        provider: "test",
-        dimensions,
-        modelId,
-        embed: embedFn,
-        embedBatch: embedBatchFn,
-        embedFn,
-        embedBatchFn,
-    };
-}
-/** Insert a minimal memory row directly into the DB. */
-function insertMemory(db, id, content, hasEmbedding = 0) {
-    db.prepare(`INSERT INTO memories (id, tenant_id, agent_id, user_id, content, trust_level, memory_type, source_who, tags, created_at, has_embedding)
-     VALUES (?, 'default', 'default', 'u1', ?, 'learned', 'semantic', 'agent', '[]', ?, ?)`).run(id, content, Date.now(), hasEmbedding);
-}
-// ---------------------------------------------------------------------------
-// Integration Tests
-// ---------------------------------------------------------------------------
-describe("Embedding pipeline integration", () => {
-    let db;
-    beforeEach(() => {
-        db = new Database(":memory:");
-        initSchema(db, DIMS);
-    });
-    it("full pipeline: store -> batch index -> search returns results", async () => {
-        const mockPort = createMockEmbeddingPort(DIMS, "test-embed-v1");
-        // Create adapter with embedding port
-        const adapter = new SqliteMemoryAdapter({ dbPath: ":memory:", walMode: false, embeddingDimensions: DIMS }, mockPort);
-        // Use the adapter's internal DB (which has the schema already initialized)
-        const adapterDb = adapter.getDb();
-        // Store 3 memories via adapter
-        const now = Date.now();
-        for (let i = 1; i <= 3; i++) {
-            await adapter.store({
-                id: `mem-${i}`,
-                tenantId: "default",
-                agentId: "default",
-                userId: "u1",
-                content: `Test memory content number ${i}`,
-                trustLevel: "learned",
-                source: { who: "agent" },
-                tags: ["test"],
-                createdAt: now + i,
-            });
-        }
-        // Create batch indexer and embed all unembedded memories
-        const batchIndexer = createBatchIndexer(adapterDb, mockPort, { batchSize: 10 });
-        const indexResult = await batchIndexer.indexUnembedded();
-        expect(indexResult.indexed).toBe(3);
-        expect(indexResult.failed).toBe(0);
-        // Search via adapter (uses embeddingPort.embed for query vector)
-        const sessionKey = { tenantId: "default", userId: "u1", channelId: "test" };
-        const searchResult = await adapter.search(sessionKey, "Test memory content", { limit: 10 });
-        expect(searchResult.ok).toBe(true);
-        if (searchResult.ok) {
-            // Should return results (FTS5 at minimum, possibly hybrid if vec is available)
-            expect(searchResult.value.length).toBeGreaterThan(0);
-        }
-    });
-    it("cache prevents redundant embedding calls", async () => {
-        const mockPort = createMockEmbeddingPort(DIMS, "cached-model");
-        // Wrap with cache
-        const cached = createCachedEmbeddingPort(mockPort, { maxEntries: 100 });
-        // Call embed with same text twice
-        const result1 = await cached.embed("same text for caching");
-        const result2 = await cached.embed("same text for caching");
-        expect(result1.ok).toBe(true);
-        expect(result2.ok).toBe(true);
-        // Inner embed should only be called once (second was cache hit)
-        expect(mockPort.embedFn).toHaveBeenCalledTimes(1);
-        // Both results should be identical
-        if (result1.ok && result2.ok) {
-            expect(result1.value).toEqual(result2.value);
-        }
-    });
-    it("fingerprint detects model change and triggers reindex", async () => {
-        const fingerprintMgr = createFingerprintManager(db);
-        fingerprintMgr.ensureTable();
-        // Create mock port A (4 dims, model-a)
-        const portA = createMockEmbeddingPort(4, "model-a");
-        // Save fingerprint for port A
-        fingerprintMgr.save(fingerprintMgr.computeFingerprint(portA));
-        // Verify no change detected for same port
-        expect(fingerprintMgr.hasChanged(portA)).toBe(false);
-        // Create mock port B (different model and dimensions)
-        const portB = createMockEmbeddingPort(4, "model-b");
-        // Should detect change since model changed
-        expect(fingerprintMgr.hasChanged(portB)).toBe(true);
-        // Insert some memories to reindex
-        insertMemory(db, "m1", "hello world", 1);
-        insertMemory(db, "m2", "test data", 1);
-        insertMemory(db, "m3", "embedding test", 1);
-        // Create batch indexer with port B and reindex all
-        const batchIndexer = createBatchIndexer(db, portB, { batchSize: 10 });
-        const result = await batchIndexer.reindexAll();
-        // All 3 should be re-embedded with port B
-        expect(result.indexed).toBe(3);
-        expect(result.failed).toBe(0);
-        expect(portB.embedBatchFn).toHaveBeenCalled();
-        // Update fingerprint to port B
-        fingerprintMgr.save(fingerprintMgr.computeFingerprint(portB));
-        // No change detected for port B now
-        expect(fingerprintMgr.hasChanged(portB)).toBe(false);
-    });
-    it("embedding queue processes new entries asynchronously", async () => {
-        const mockPort = createMockEmbeddingPort(DIMS, "queue-model");
-        // Insert entries first so the queue can update their has_embedding flag
-        insertMemory(db, "q1", "queue entry one");
-        insertMemory(db, "q2", "queue entry two");
-        insertMemory(db, "q3", "queue entry three");
-        // Create embedding queue
-        const queue = createEmbeddingQueue(db, mockPort);
-        // Enqueue 3 entries
-        queue.enqueue("q1", "queue entry one");
-        queue.enqueue("q2", "queue entry two");
-        queue.enqueue("q3", "queue entry three");
-        // Wait for queue to process all entries
-        await queue.onIdle();
-        // Verify has_embedding = 1 for all 3 entries
-        const rows = db
-            .prepare("SELECT id, has_embedding FROM memories WHERE id IN ('q1', 'q2', 'q3')")
-            .all();
-        for (const row of rows) {
-            expect(row.has_embedding).toBe(1);
-        }
-        // Verify vec_memories has rows (if vec is available)
-        if (isVecAvailable()) {
-            const vecCount = db
-                .prepare("SELECT COUNT(*) as cnt FROM vec_memories")
-                .get();
-            expect(vecCount.cnt).toBe(3);
-        }
-    });
-    it("graceful degradation: no embedding port uses FTS5 only", async () => {
-        // Create SqliteMemoryAdapter WITHOUT embedding port
-        const adapter = new SqliteMemoryAdapter({ dbPath: ":memory:", walMode: false, embeddingDimensions: DIMS });
-        const adapterDb = adapter.getDb();
-        // Store memories
-        const now = Date.now();
-        for (let i = 1; i <= 3; i++) {
-            await adapter.store({
-                id: `fts-${i}`,
-                tenantId: "default",
-                agentId: "default",
-                userId: "u1",
-                content: `Searchable memory about topic ${i}`,
-                trustLevel: "learned",
-                source: { who: "agent" },
-                tags: [],
-                createdAt: now + i,
-            });
-        }
-        // Search by text -- should return results via FTS5
-        const sessionKey = { tenantId: "default", userId: "u1", channelId: "test" };
-        const searchResult = await adapter.search(sessionKey, "Searchable memory topic", { limit: 10 });
-        expect(searchResult.ok).toBe(true);
-        if (searchResult.ok) {
-            expect(searchResult.value.length).toBeGreaterThan(0);
-        }
-        // Verify no embeddings were generated
-        const embeddedCount = adapterDb
-            .prepare("SELECT COUNT(*) as cnt FROM memories WHERE has_embedding = 1")
-            .get();
-        expect(embeddedCount.cnt).toBe(0);
-    });
-    it("batch indexer handles embedBatch failure gracefully", async () => {
-        // Create mock port that always fails embedBatch
-        const failPort = {
-            provider: "test",
-            dimensions: DIMS,
-            modelId: "fail-model",
-            embed: vi.fn().mockResolvedValue(err(new Error("embed failed"))),
-            embedBatch: vi.fn().mockResolvedValue(err(new Error("batch failed"))),
-        };
-        // Insert memories to index
-        insertMemory(db, "f1", "should fail embedding");
-        insertMemory(db, "f2", "also should fail");
-        insertMemory(db, "f3", "failing too");
-        const indexer = createBatchIndexer(db, failPort, { batchSize: 10 });
-        const result = await indexer.indexUnembedded();
-        // All should fail
-        expect(result.indexed).toBe(0);
-        expect(result.failed).toBe(3);
-        // Memories still have has_embedding = 0
-        const unembedded = indexer.unembeddedCount();
-        expect(unembedded).toBe(3);
-        // embedBatch was called once (then stopped due to failure-stop behavior)
-        expect(failPort.embedBatch).toHaveBeenCalledTimes(1);
-    });
-});

package/node_modules/@comis/memory/dist/embedding-provider-factory.test.d.ts

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