comisai 1.0.10 → 1.0.12

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

@@ -1,176 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { ok, err } from "@comis/shared";
-// Mock the local and openai provider modules
-vi.mock("./embedding-provider-local.js", () => ({
-    createLocalEmbeddingProvider: vi.fn(),
-}));
-vi.mock("./embedding-provider-openai.js", () => ({
-    createOpenAIEmbeddingProvider: vi.fn(),
-}));
-import { createEmbeddingProvider } from "./embedding-provider-factory.js";
-import { createLocalEmbeddingProvider } from "./embedding-provider-local.js";
-import { createOpenAIEmbeddingProvider } from "./embedding-provider-openai.js";
-const mockLocal = vi.mocked(createLocalEmbeddingProvider);
-const mockOpenAI = vi.mocked(createOpenAIEmbeddingProvider);
-function stubPort(overrides) {
-    return {
-        provider: "test",
-        dimensions: 768,
-        modelId: "test-model",
-        embed: vi.fn().mockResolvedValue(ok([0.1, 0.2])),
-        embedBatch: vi.fn().mockResolvedValue(ok([[0.1], [0.2]])),
-        ...overrides,
-    };
-}
-describe("createEmbeddingProvider", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    describe("auto mode", () => {
-        it("selects local when local succeeds", async () => {
-            const localPort = stubPort({ modelId: "local-model" });
-            mockLocal.mockResolvedValue(ok(localPort));
-            const result = await createEmbeddingProvider({
-                provider: "auto",
-                local: { modelUri: "hf:test", modelsDir: "models" },
-                remote: { apiKey: "sk-test", model: "text-embedding-3-small", dimensions: 1536 },
-            });
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.modelId).toBe("local-model");
-            }
-            expect(mockLocal).toHaveBeenCalledOnce();
-            // Remote should NOT have been called since local succeeded
-            expect(mockOpenAI).not.toHaveBeenCalled();
-        });
-        it("falls back to remote when local fails", async () => {
-            mockLocal.mockResolvedValue(err(new Error("node-llama-cpp not available")));
-            const remotePort = stubPort({ modelId: "openai-model", dimensions: 1536 });
-            mockOpenAI.mockReturnValue(ok(remotePort));
-            const result = await createEmbeddingProvider({
-                provider: "auto",
-                local: { modelUri: "hf:test", modelsDir: "models" },
-                remote: { apiKey: "sk-test", model: "text-embedding-3-small", dimensions: 1536 },
-            });
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.modelId).toBe("openai-model");
-            }
-            expect(mockLocal).toHaveBeenCalledOnce();
-            expect(mockOpenAI).toHaveBeenCalledOnce();
-        });
-        it("returns error when both fail", async () => {
-            mockLocal.mockResolvedValue(err(new Error("native bindings unavailable")));
-            mockOpenAI.mockReturnValue(err(new Error("OpenAI embedding provider requires an apiKey")));
-            const result = await createEmbeddingProvider({
-                provider: "auto",
-                local: { modelUri: "hf:test", modelsDir: "models" },
-                remote: { apiKey: "", model: "text-embedding-3-small", dimensions: 1536 },
-            });
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.message).toContain("No embedding provider available");
-                expect(result.error.message).toContain("native bindings unavailable");
-            }
-        });
-        it("skips local when no local config provided", async () => {
-            const remotePort = stubPort({ modelId: "openai-fallback" });
-            mockOpenAI.mockReturnValue(ok(remotePort));
-            const result = await createEmbeddingProvider({
-                provider: "auto",
-                remote: { apiKey: "sk-test", model: "text-embedding-3-small", dimensions: 1536 },
-            });
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.modelId).toBe("openai-fallback");
-            }
-            expect(mockLocal).not.toHaveBeenCalled();
-        });
-    });
-    describe("local mode", () => {
-        it("returns error when local fails (no fallback)", async () => {
-            mockLocal.mockResolvedValue(err(new Error("model file not found")));
-            const result = await createEmbeddingProvider({
-                provider: "local",
-                local: { modelUri: "hf:test", modelsDir: "models" },
-                remote: { apiKey: "sk-test", model: "text-embedding-3-small", dimensions: 1536 },
-            });
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.message).toBe("model file not found");
-            }
-            // Remote should NOT be attempted for explicit local mode
-            expect(mockOpenAI).not.toHaveBeenCalled();
-        });
-        it("returns error when no local config provided", async () => {
-            const result = await createEmbeddingProvider({
-                provider: "local",
-            });
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.message).toContain("no local config provided");
-            }
-        });
-        it("succeeds when local provider works", async () => {
-            const localPort = stubPort({ modelId: "local-gguf" });
-            mockLocal.mockResolvedValue(ok(localPort));
-            const result = await createEmbeddingProvider({
-                provider: "local",
-                local: { modelUri: "/path/to/model.gguf", modelsDir: "models" },
-            });
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.modelId).toBe("local-gguf");
-            }
-        });
-    });
-    describe("openai mode", () => {
-        it("returns error when no apiKey provided", async () => {
-            const result = await createEmbeddingProvider({
-                provider: "openai",
-            });
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.message).toContain("apiKey");
-            }
-        });
-        it("returns error when apiKey is empty string", async () => {
-            const result = await createEmbeddingProvider({
-                provider: "openai",
-                remote: { apiKey: "", model: "text-embedding-3-small", dimensions: 1536 },
-            });
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.message).toContain("apiKey");
-            }
-        });
-        it("succeeds with valid config", async () => {
-            const remotePort = stubPort({ modelId: "text-embedding-3-small", dimensions: 1536 });
-            mockOpenAI.mockReturnValue(ok(remotePort));
-            const result = await createEmbeddingProvider({
-                provider: "openai",
-                remote: { apiKey: "sk-valid-key", model: "text-embedding-3-small", dimensions: 1536 },
-            });
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.modelId).toBe("text-embedding-3-small");
-                expect(result.value.dimensions).toBe(1536);
-            }
-            expect(mockOpenAI).toHaveBeenCalledWith({
-                apiKey: "sk-valid-key",
-                model: "text-embedding-3-small",
-                dimensions: 1536,
-            });
-        });
-        it("does not attempt local provider", async () => {
-            const remotePort = stubPort();
-            mockOpenAI.mockReturnValue(ok(remotePort));
-            await createEmbeddingProvider({
-                provider: "openai",
-                local: { modelUri: "hf:test", modelsDir: "models" },
-                remote: { apiKey: "sk-test", model: "text-embedding-3-small", dimensions: 1536 },
-            });
-            expect(mockLocal).not.toHaveBeenCalled();
-        });
-    });
-});

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

@@ -1,8 +0,0 @@
-/**
- * Contract tests for the local (node-llama-cpp) embedding provider.
- *
- * Tests gated behind LLAMA_MODEL_PATH are silently skipped in normal
- * CI runs and only execute when the env var points to a valid GGUF model.
- * The invalid-model-path error handling test runs unconditionally.
- */
-export {};

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

@@ -1,76 +0,0 @@
-/**
- * Contract tests for the local (node-llama-cpp) embedding provider.
- *
- * Tests gated behind LLAMA_MODEL_PATH are silently skipped in normal
- * CI runs and only execute when the env var points to a valid GGUF model.
- * The invalid-model-path error handling test runs unconditionally.
- */
-import { describe, it, expect } from "vitest";
-import { createLocalEmbeddingProvider } from "./embedding-provider-local.js";
-const LLAMA_MODEL_PATH = process.env.LLAMA_MODEL_PATH;
-describe.skipIf(!LLAMA_MODEL_PATH)("Local embedding provider (contract test)", () => {
-    it("creates provider successfully with valid model path", async () => {
-        const result = await createLocalEmbeddingProvider({
-            modelUri: LLAMA_MODEL_PATH,
-            modelsDir: "/tmp/comis-test-models",
-        });
-        expect(result.ok).toBe(true);
-        if (result.ok) {
-            expect(result.value.dimensions).toBeGreaterThan(0);
-            expect(result.value.modelId).toBe(LLAMA_MODEL_PATH);
-        }
-    });
-    it("generates embedding with correct dimensions", async () => {
-        const createResult = await createLocalEmbeddingProvider({
-            modelUri: LLAMA_MODEL_PATH,
-            modelsDir: "/tmp/comis-test-models",
-        });
-        expect(createResult.ok).toBe(true);
-        if (!createResult.ok)
-            return;
-        const provider = createResult.value;
-        const result = await provider.embed("Test text for local embedding");
-        expect(result.ok).toBe(true);
-        if (result.ok) {
-            expect(result.value).toBeInstanceOf(Array);
-            expect(result.value.length).toBe(provider.dimensions);
-            // All values should be finite numbers
-            for (const val of result.value) {
-                expect(Number.isFinite(val)).toBe(true);
-            }
-        }
-    });
-    it("generates batch embeddings", async () => {
-        const createResult = await createLocalEmbeddingProvider({
-            modelUri: LLAMA_MODEL_PATH,
-            modelsDir: "/tmp/comis-test-models",
-        });
-        expect(createResult.ok).toBe(true);
-        if (!createResult.ok)
-            return;
-        const provider = createResult.value;
-        const result = await provider.embedBatch(["Hello", "World"]);
-        expect(result.ok).toBe(true);
-        if (result.ok) {
-            expect(result.value).toHaveLength(2);
-            for (const embedding of result.value) {
-                expect(embedding.length).toBe(provider.dimensions);
-            }
-        }
-    });
-});
-// Ungated test: verify error handling with invalid model path
-describe("Local embedding provider (error handling)", () => {
-    it("handles invalid model path gracefully", async () => {
-        const result = await createLocalEmbeddingProvider({
-            modelUri: "/nonexistent/model.gguf",
-            modelsDir: "/tmp/comis-test-models",
-        });
-        // Should return err() with a meaningful error, not crash
-        expect(result.ok).toBe(false);
-        if (!result.ok) {
-            expect(result.error).toBeInstanceOf(Error);
-            expect(result.error.message.length).toBeGreaterThan(0);
-        }
-    });
-});

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

@@ -1,8 +0,0 @@
-/**
- * Contract tests for the OpenAI embedding provider.
- *
- * These tests call the real OpenAI API and are gated behind the
- * OPENAI_API_KEY environment variable. They are silently skipped
- * in normal CI runs and only execute when the env var is set.
- */
-export {};

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

@@ -1,100 +0,0 @@
-/**
- * Contract tests for the OpenAI embedding provider.
- *
- * These tests call the real OpenAI API and are gated behind the
- * OPENAI_API_KEY environment variable. They are silently skipped
- * in normal CI runs and only execute when the env var is set.
- */
-import { describe, it, expect } from "vitest";
-import { createOpenAIEmbeddingProvider } from "./embedding-provider-openai.js";
-const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
-describe.skipIf(!OPENAI_API_KEY)("OpenAI embedding provider (contract test)", () => {
-    it("creates provider successfully", () => {
-        const result = createOpenAIEmbeddingProvider({
-            apiKey: OPENAI_API_KEY,
-            model: "text-embedding-3-small",
-            dimensions: 1536,
-        });
-        expect(result.ok).toBe(true);
-        if (result.ok) {
-            expect(result.value.dimensions).toBe(1536);
-            expect(result.value.modelId).toBe("text-embedding-3-small");
-        }
-    });
-    it("generates embedding for single text", async () => {
-        const createResult = createOpenAIEmbeddingProvider({
-            apiKey: OPENAI_API_KEY,
-            model: "text-embedding-3-small",
-            dimensions: 1536,
-        });
-        expect(createResult.ok).toBe(true);
-        if (!createResult.ok)
-            return;
-        const provider = createResult.value;
-        const result = await provider.embed("Hello world");
-        expect(result.ok).toBe(true);
-        if (result.ok) {
-            expect(result.value).toBeInstanceOf(Array);
-            expect(result.value.length).toBe(1536);
-            // All values should be finite numbers
-            for (const val of result.value) {
-                expect(Number.isFinite(val)).toBe(true);
-            }
-        }
-    });
-    it("generates embeddings for batch", async () => {
-        const createResult = createOpenAIEmbeddingProvider({
-            apiKey: OPENAI_API_KEY,
-            model: "text-embedding-3-small",
-            dimensions: 1536,
-        });
-        expect(createResult.ok).toBe(true);
-        if (!createResult.ok)
-            return;
-        const provider = createResult.value;
-        const result = await provider.embedBatch(["Hello", "World"]);
-        expect(result.ok).toBe(true);
-        if (result.ok) {
-            expect(result.value).toHaveLength(2);
-            for (const embedding of result.value) {
-                expect(embedding.length).toBe(1536);
-                for (const val of embedding) {
-                    expect(Number.isFinite(val)).toBe(true);
-                }
-            }
-        }
-    });
-    it("returns error for empty text", async () => {
-        const createResult = createOpenAIEmbeddingProvider({
-            apiKey: OPENAI_API_KEY,
-            model: "text-embedding-3-small",
-            dimensions: 1536,
-        });
-        expect(createResult.ok).toBe(true);
-        if (!createResult.ok)
-            return;
-        const provider = createResult.value;
-        const result = await provider.embed("");
-        // OpenAI may reject empty strings with an error, or return a zero vector.
-        // Either behavior is acceptable -- we verify it does not crash.
-        if (!result.ok) {
-            expect(result.error).toBeInstanceOf(Error);
-        }
-        else {
-            expect(result.value.length).toBe(1536);
-        }
-    });
-});
-// Ungated test: verify provider creation fails with bad API key format
-describe("OpenAI embedding provider (error handling)", () => {
-    it("creates provider with any apiKey format (validation is lazy)", () => {
-        // The OpenAI SDK accepts any string as apiKey at construction time.
-        // Actual validation happens at call time. Verify creation succeeds.
-        const result = createOpenAIEmbeddingProvider({
-            apiKey: "sk-invalid-key-for-testing",
-            model: "text-embedding-3-small",
-            dimensions: 1536,
-        });
-        expect(result.ok).toBe(true);
-    });
-});

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

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

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

@@ -1,236 +0,0 @@
-import { ok, err } from "@comis/shared";
-import Database from "better-sqlite3";
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import { createEmbeddingQueue } from "./embedding-queue.js";
-import { initSchema, isVecAvailable } from "./schema.js";
-const DIMS = 4;
-/**
- * Create a mock EmbeddingPort that returns deterministic embeddings.
- * Tracks call order via the `calls` array for FIFO verification.
- */
-function createMockEmbeddingPort(opts) {
-    const calls = [];
-    const delay = opts?.delay ?? 0;
-    const fail = opts?.fail ?? false;
-    return {
-        provider: "test",
-        dimensions: DIMS,
-        modelId: "test-embed-model",
-        calls,
-        async embed(text) {
-            calls.push(text);
-            if (delay > 0) {
-                await new Promise((r) => setTimeout(r, delay));
-            }
-            if (fail) {
-                return err(new Error("mock embedding failure"));
-            }
-            // Deterministic vector based on text chars
-            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);
-        },
-        async embedBatch(texts) {
-            const results = [];
-            for (const t of texts) {
-                const r = await this.embed(t);
-                if (r.ok)
-                    results.push(r.value);
-            }
-            return ok(results);
-        },
-    };
-}
-/** Insert a minimal memory row into the database. */
-function insertMemory(db, id, content) {
-    db.prepare(`INSERT INTO memories (id, tenant_id, user_id, content, trust_level, memory_type, source_who, tags, created_at)
-     VALUES (?, 'default', 'u1', ?, 'learned', 'semantic', 'agent', '[]', ?)`).run(id, content, Date.now());
-}
-describe("createEmbeddingQueue", () => {
-    let db;
-    beforeEach(() => {
-        db = new Database(":memory:");
-        initSchema(db, DIMS);
-    });
-    it("enqueue does not block (returns immediately before embedding completes)", async () => {
-        const port = createMockEmbeddingPort({ delay: 50 });
-        const queue = createEmbeddingQueue(db, port);
-        insertMemory(db, "m1", "hello world");
-        queue.enqueue("m1", "hello world");
-        // The call should have returned immediately -- check that the embedding
-        // is NOT yet stored (still processing in background)
-        const row = db.prepare("SELECT has_embedding FROM memories WHERE id = 'm1'").get();
-        expect(row.has_embedding).toBe(0);
-        // Now wait for completion
-        await queue.onIdle();
-        const after = db.prepare("SELECT has_embedding FROM memories WHERE id = 'm1'").get();
-        expect(after.has_embedding).toBe(1);
-    });
-    it("after onIdle(), entry has embedding in vec_memories", async () => {
-        if (!isVecAvailable())
-            return;
-        const port = createMockEmbeddingPort();
-        const queue = createEmbeddingQueue(db, port);
-        insertMemory(db, "m1", "test content");
-        queue.enqueue("m1", "test content");
-        await queue.onIdle();
-        const vecRow = db.prepare("SELECT memory_id FROM vec_memories WHERE memory_id = 'm1'").get();
-        expect(vecRow).toBeDefined();
-        expect(vecRow.memory_id).toBe("m1");
-    });
-    it("after onIdle(), memories.has_embedding = 1", async () => {
-        const port = createMockEmbeddingPort();
-        const queue = createEmbeddingQueue(db, port);
-        insertMemory(db, "m1", "test content");
-        queue.enqueue("m1", "test content");
-        await queue.onIdle();
-        const row = db.prepare("SELECT has_embedding FROM memories WHERE id = 'm1'").get();
-        expect(row.has_embedding).toBe(1);
-    });
-    it("multiple enqueues process FIFO (call order matches enqueue order)", async () => {
-        const port = createMockEmbeddingPort();
-        const queue = createEmbeddingQueue(db, port);
-        insertMemory(db, "m1", "first");
-        insertMemory(db, "m2", "second");
-        insertMemory(db, "m3", "third");
-        queue.enqueue("m1", "first");
-        queue.enqueue("m2", "second");
-        queue.enqueue("m3", "third");
-        await queue.onIdle();
-        expect(port.calls).toEqual(["first", "second", "third"]);
-    });
-    it("concurrency=1: second embed does not start until first finishes", async () => {
-        const timeline = [];
-        const port = {
-            provider: "test",
-            dimensions: DIMS,
-            modelId: "test-embed-model",
-            calls: [],
-            async embed(text) {
-                this.calls.push(text);
-                timeline.push({ text, event: "start" });
-                await new Promise((r) => setTimeout(r, 30));
-                timeline.push({ text, event: "end" });
-                return ok(new Array(DIMS).fill(0.5));
-            },
-            async embedBatch(texts) {
-                return ok(texts.map(() => new Array(DIMS).fill(0.5)));
-            },
-        };
-        const queue = createEmbeddingQueue(db, port);
-        insertMemory(db, "m1", "alpha");
-        insertMemory(db, "m2", "beta");
-        queue.enqueue("m1", "alpha");
-        queue.enqueue("m2", "beta");
-        await queue.onIdle();
-        // With concurrency=1, "alpha" must end before "beta" starts
-        const alphaEnd = timeline.findIndex((e) => e.text === "alpha" && e.event === "end");
-        const betaStart = timeline.findIndex((e) => e.text === "beta" && e.event === "start");
-        expect(alphaEnd).toBeLessThan(betaStart);
-    });
-    it("failed embedding does not crash queue (entry stays without embedding)", async () => {
-        const port = createMockEmbeddingPort({ fail: true });
-        const queue = createEmbeddingQueue(db, port);
-        insertMemory(db, "m1", "will fail");
-        queue.enqueue("m1", "will fail");
-        // Should not throw
-        await queue.onIdle();
-        // Entry should still exist but without embedding
-        const row = db.prepare("SELECT has_embedding FROM memories WHERE id = 'm1'").get();
-        expect(row.has_embedding).toBe(0);
-        // Memory itself is intact
-        const mem = db.prepare("SELECT content FROM memories WHERE id = 'm1'").get();
-        expect(mem.content).toBe("will fail");
-    });
-    it("failed embedding logs warning via structured logger", async () => {
-        const mockLogger = { warn: vi.fn() };
-        const port = createMockEmbeddingPort({ fail: true });
-        const queue = createEmbeddingQueue(db, port, mockLogger);
-        insertMemory(db, "m1", "will fail");
-        queue.enqueue("m1", "will fail");
-        await queue.onIdle();
-        expect(mockLogger.warn).toHaveBeenCalledWith(expect.objectContaining({
-            entryId: "m1",
-            err: expect.stringContaining("mock embedding failure"),
-            hint: expect.stringContaining("FTS5"),
-            errorKind: "dependency",
-        }), "Embedding generation failed");
-    });
-    it("pending() returns correct count before and after processing", async () => {
-        const port = createMockEmbeddingPort({ delay: 30 });
-        const queue = createEmbeddingQueue(db, port);
-        // Before any enqueue
-        expect(queue.pending()).toBe(0);
-        insertMemory(db, "m1", "a");
-        insertMemory(db, "m2", "b");
-        insertMemory(db, "m3", "c");
-        queue.enqueue("m1", "a");
-        queue.enqueue("m2", "b");
-        queue.enqueue("m3", "c");
-        // At least some should be pending (1 running + others queued)
-        expect(queue.pending()).toBeGreaterThan(0);
-        await queue.onIdle();
-        expect(queue.pending()).toBe(0);
-    });
-    it("pause() stops processing, resume() continues", async () => {
-        const port = createMockEmbeddingPort({ delay: 10 });
-        const queue = createEmbeddingQueue(db, port);
-        insertMemory(db, "m1", "a");
-        insertMemory(db, "m2", "b");
-        queue.pause();
-        queue.enqueue("m1", "a");
-        queue.enqueue("m2", "b");
-        // Give a tick for anything that might process
-        await new Promise((r) => setTimeout(r, 50));
-        // Nothing should have been processed while paused
-        expect(port.calls).toHaveLength(0);
-        queue.resume();
-        await queue.onIdle();
-        expect(port.calls).toHaveLength(2);
-    });
-    it("clear() removes pending items", async () => {
-        const port = createMockEmbeddingPort({ delay: 50 });
-        const queue = createEmbeddingQueue(db, port);
-        insertMemory(db, "m1", "a");
-        insertMemory(db, "m2", "b");
-        insertMemory(db, "m3", "c");
-        queue.enqueue("m1", "a");
-        queue.enqueue("m2", "b");
-        queue.enqueue("m3", "c");
-        // Clear pending (in-progress item may still complete)
-        queue.clear();
-        await queue.onIdle();
-        // Only the first item (already in-progress when clear was called) should have been processed
-        // or possibly none if clear was very fast. At most 1 should complete.
-        expect(port.calls.length).toBeLessThanOrEqual(1);
-    });
-    it("onIdle() resolves immediately when queue is empty", async () => {
-        const port = createMockEmbeddingPort();
-        const queue = createEmbeddingQueue(db, port);
-        const start = Date.now();
-        await queue.onIdle();
-        const elapsed = Date.now() - start;
-        // Should resolve nearly instantly (under 50ms)
-        expect(elapsed).toBeLessThan(50);
-    });
-    it("embedding is stored as Float32Array in vec_memories", async () => {
-        if (!isVecAvailable())
-            return;
-        const port = createMockEmbeddingPort();
-        const queue = createEmbeddingQueue(db, port);
-        insertMemory(db, "m1", "AB");
-        queue.enqueue("m1", "AB");
-        await queue.onIdle();
-        // Query the raw embedding from vec_memories
-        const vecRow = db.prepare("SELECT embedding FROM vec_memories WHERE memory_id = 'm1'").get();
-        expect(vecRow).toBeDefined();
-        // Convert Buffer back to Float32Array and verify values
-        const float32 = new Float32Array(vecRow.embedding.buffer, vecRow.embedding.byteOffset, vecRow.embedding.byteLength / Float32Array.BYTES_PER_ELEMENT);
-        expect(float32.length).toBe(DIMS);
-        // "A" = 65, "B" = 66; charCode / 256
-        expect(float32[0]).toBeCloseTo(65 / 256, 5);
-        expect(float32[1]).toBeCloseTo(66 / 256, 5);
-    });
-});

package/node_modules/@comis/memory/dist/hybrid-search.test.d.ts

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