comisai 1.0.10 → 1.0.12

package/node_modules/@comis/memory/dist/compaction.test.js

@@ -1,298 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { createCompactionService } from "./compaction.js";
-import { createSessionStore } from "./session-store.js";
-import { SqliteMemoryAdapter } from "./sqlite-memory-adapter.js";
-// ── Helpers ────────────────────────────────────────────────────────────
-const testConfig = {
-    dbPath: ":memory:",
-    walMode: false,
-    embeddingModel: "test-model",
-    embeddingDimensions: 4,
-    compaction: { enabled: false, threshold: 1000, targetSize: 500 },
-    retention: { maxAgeDays: 0, maxEntries: 0 },
-};
-const testKey = {
-    tenantId: "default",
-    userId: "user-1",
-    channelId: "telegram",
-};
-const testKey2 = {
-    tenantId: "default",
-    userId: "user-2",
-    channelId: "discord",
-};
-/** Simple summarizer that just concatenates messages and returns fixed facts. */
-const mockSummarizer = async (messages) => ({
-    summary: `Summary of ${messages.length} messages`,
-    facts: ["fact-1", "fact-2"],
-});
-/** Summarizer that returns no facts. */
-const noFactsSummarizer = async (messages) => ({
-    summary: `Summary of ${messages.length} messages`,
-    facts: [],
-});
-/** Summarizer that tracks how many times it was called. */
-function trackingSummarizer() {
-    const fn = async (messages) => {
-        fn.callCount++;
-        return {
-            summary: `Summary of ${messages.length} messages`,
-            facts: ["tracked-fact"],
-        };
-    };
-    fn.callCount = 0;
-    return fn;
-}
-// ── Test Suite ─────────────────────────────────────────────────────────
-describe("createCompactionService", () => {
-    let db;
-    let adapter;
-    let sessionStore;
-    let compactionService;
-    beforeEach(() => {
-        // Use the adapter's internal DB for everything (single :memory: connection)
-        adapter = new SqliteMemoryAdapter(testConfig);
-        db = adapter.getDb();
-        sessionStore = createSessionStore(db);
-        compactionService = createCompactionService(db, sessionStore, adapter, mockSummarizer);
-    });
-    afterEach(() => {
-        adapter.close();
-    });
-    // ── Stale session detection ──────────────────────────────────────
-    it("compacts sessions idle for longer than minIdleMs", async () => {
-        // Save a session and manually set its updatedAt to the past
-        sessionStore.save(testKey, [{ role: "user", content: "hello" }]);
-        // Set updatedAt to 5 hours ago
-        const fiveHoursAgo = Date.now() - 5 * 60 * 60 * 1000;
-        db.prepare("UPDATE sessions SET updated_at = ? WHERE session_key = ?").run(fiveHoursAgo, "default:user-1:telegram");
-        const result = await compactionService.compact({ minIdleMs: 4 * 60 * 60 * 1000 });
-        expect(result.sessionsCompacted).toBe(1);
-        expect(result.compactedKeys).toContain("default:user-1:telegram");
-    });
-    it("does NOT compact active sessions (within idle threshold)", async () => {
-        // Save a session that was recently updated (within minIdleMs)
-        sessionStore.save(testKey, [{ role: "user", content: "hello" }]);
-        const result = await compactionService.compact({ minIdleMs: 4 * 60 * 60 * 1000 });
-        expect(result.sessionsCompacted).toBe(0);
-        expect(result.compactedKeys).toHaveLength(0);
-    });
-    it("skips sessions with no messages", async () => {
-        sessionStore.save(testKey, []);
-        const longAgo = Date.now() - 10 * 60 * 60 * 1000;
-        db.prepare("UPDATE sessions SET updated_at = ? WHERE session_key = ?").run(longAgo, "default:user-1:telegram");
-        const result = await compactionService.compact({ minIdleMs: 1000 });
-        expect(result.sessionsCompacted).toBe(0);
-    });
-    // ── Episodic memory creation ─────────────────────────────────────
-    it("creates episodic memory from stale session summary", async () => {
-        sessionStore.save(testKey, [
-            { role: "user", content: "hello" },
-            { role: "assistant", content: "hi" },
-        ]);
-        const longAgo = Date.now() - 10 * 60 * 60 * 1000;
-        db.prepare("UPDATE sessions SET updated_at = ? WHERE session_key = ?").run(longAgo, "default:user-1:telegram");
-        const result = await compactionService.compact({ minIdleMs: 1000 });
-        expect(result.episodicCreated).toBe(1);
-        // Verify the episodic memory is in the database
-        const episodic = db
-            .prepare("SELECT * FROM memories WHERE memory_type = 'episodic'")
-            .all();
-        expect(episodic).toHaveLength(1);
-        expect(episodic[0].content).toBe("Summary of 2 messages");
-        expect(episodic[0].source_who).toBe("compaction");
-    });
-    // ── Semantic fact extraction ─────────────────────────────────────
-    it("creates semantic memories from extracted facts", async () => {
-        sessionStore.save(testKey, [{ role: "user", content: "hello" }]);
-        const longAgo = Date.now() - 10 * 60 * 60 * 1000;
-        db.prepare("UPDATE sessions SET updated_at = ? WHERE session_key = ?").run(longAgo, "default:user-1:telegram");
-        const result = await compactionService.compact({ minIdleMs: 1000 });
-        expect(result.factsExtracted).toBe(2);
-        const facts = db
-            .prepare("SELECT content FROM memories WHERE memory_type = 'semantic' AND tags LIKE '%fact%'")
-            .all();
-        expect(facts).toHaveLength(2);
-        expect(facts.map((f) => f.content)).toContain("fact-1");
-        expect(facts.map((f) => f.content)).toContain("fact-2");
-    });
-    it("handles summarizer returning no facts", async () => {
-        const service = createCompactionService(db, sessionStore, adapter, noFactsSummarizer);
-        sessionStore.save(testKey, [{ role: "user", content: "hello" }]);
-        const longAgo = Date.now() - 10 * 60 * 60 * 1000;
-        db.prepare("UPDATE sessions SET updated_at = ? WHERE session_key = ?").run(longAgo, "default:user-1:telegram");
-        const result = await service.compact({ minIdleMs: 1000 });
-        expect(result.episodicCreated).toBe(1);
-        expect(result.factsExtracted).toBe(0);
-    });
-    // ── Archive creation ─────────────────────────────────────────────
-    it("archives original messages before deletion", async () => {
-        const messages = [
-            { role: "user", content: "hello" },
-            { role: "assistant", content: "hi there" },
-        ];
-        sessionStore.save(testKey, messages);
-        const longAgo = Date.now() - 10 * 60 * 60 * 1000;
-        db.prepare("UPDATE sessions SET updated_at = ? WHERE session_key = ?").run(longAgo, "default:user-1:telegram");
-        await compactionService.compact({ minIdleMs: 1000 });
-        const archives = db.prepare("SELECT * FROM archives").all();
-        expect(archives).toHaveLength(1);
-        expect(archives[0].session_key).toBe("default:user-1:telegram");
-        expect(JSON.parse(archives[0].messages)).toEqual(messages);
-        expect(archives[0].expires_at).toBeGreaterThan(archives[0].archived_at);
-    });
-    it("archives respect configurable retention period", async () => {
-        sessionStore.save(testKey, [{ role: "user", content: "hello" }]);
-        const longAgo = Date.now() - 10 * 60 * 60 * 1000;
-        db.prepare("UPDATE sessions SET updated_at = ? WHERE session_key = ?").run(longAgo, "default:user-1:telegram");
-        const customRetention = 3 * 24 * 60 * 60 * 1000; // 3 days
-        await compactionService.compact({
-            minIdleMs: 1000,
-            archiveRetentionMs: customRetention,
-        });
-        const archive = db.prepare("SELECT * FROM archives").get();
-        const actualRetention = archive.expires_at - archive.archived_at;
-        expect(actualRetention).toBe(customRetention);
-    });
-    // ── Session deletion ─────────────────────────────────────────────
-    it("deletes the session after compaction", async () => {
-        sessionStore.save(testKey, [{ role: "user", content: "hello" }]);
-        const longAgo = Date.now() - 10 * 60 * 60 * 1000;
-        db.prepare("UPDATE sessions SET updated_at = ? WHERE session_key = ?").run(longAgo, "default:user-1:telegram");
-        await compactionService.compact({ minIdleMs: 1000 });
-        const session = sessionStore.load(testKey);
-        expect(session).toBeUndefined();
-    });
-    // ── Multiple sessions ────────────────────────────────────────────
-    it("compacts multiple stale sessions in one run", async () => {
-        sessionStore.save(testKey, [{ role: "user", content: "hello from user 1" }]);
-        sessionStore.save(testKey2, [{ role: "user", content: "hello from user 2" }]);
-        const longAgo = Date.now() - 10 * 60 * 60 * 1000;
-        db.prepare("UPDATE sessions SET updated_at = ?").run(longAgo);
-        const result = await compactionService.compact({ minIdleMs: 1000 });
-        expect(result.sessionsCompacted).toBe(2);
-        expect(result.episodicCreated).toBe(2);
-        expect(result.factsExtracted).toBe(4); // 2 facts per session
-    });
-    it("only compacts stale sessions, leaves active ones alone", async () => {
-        sessionStore.save(testKey, [{ role: "user", content: "stale" }]);
-        sessionStore.save(testKey2, [{ role: "user", content: "active" }]);
-        // Only make testKey stale
-        const longAgo = Date.now() - 10 * 60 * 60 * 1000;
-        db.prepare("UPDATE sessions SET updated_at = ? WHERE session_key = ?").run(longAgo, "default:user-1:telegram");
-        const result = await compactionService.compact({ minIdleMs: 1000 });
-        expect(result.sessionsCompacted).toBe(1);
-        expect(result.compactedKeys).toContain("default:user-1:telegram");
-        // Active session should still exist
-        const activeSession = sessionStore.load(testKey2);
-        expect(activeSession).toBeDefined();
-    });
-    // ── Pluggable summarizer ─────────────────────────────────────────
-    it("calls the pluggable summarizer with session messages", async () => {
-        const tracker = trackingSummarizer();
-        const service = createCompactionService(db, sessionStore, adapter, tracker);
-        const messages = [
-            { role: "user", content: "hello" },
-            { role: "assistant", content: "hi" },
-            { role: "user", content: "bye" },
-        ];
-        sessionStore.save(testKey, messages);
-        const longAgo = Date.now() - 10 * 60 * 60 * 1000;
-        db.prepare("UPDATE sessions SET updated_at = ? WHERE session_key = ?").run(longAgo, "default:user-1:telegram");
-        await service.compact({ minIdleMs: 1000 });
-        expect(tracker.callCount).toBe(1);
-    });
-    // ── Tenant scoping ──────────────────────────────────────────────
-    it("respects tenantId option for scoped compaction", async () => {
-        const key1 = { tenantId: "tenant-a", userId: "u1", channelId: "ch1" };
-        const key2 = { tenantId: "tenant-b", userId: "u2", channelId: "ch2" };
-        sessionStore.save(key1, [{ role: "user", content: "hello" }]);
-        sessionStore.save(key2, [{ role: "user", content: "world" }]);
-        const longAgo = Date.now() - 10 * 60 * 60 * 1000;
-        db.prepare("UPDATE sessions SET updated_at = ?").run(longAgo);
-        const result = await compactionService.compact({
-            minIdleMs: 1000,
-            tenantId: "tenant-a",
-        });
-        expect(result.sessionsCompacted).toBe(1);
-        expect(result.compactedKeys[0]).toContain("tenant-a");
-        // tenant-b session should still exist
-        const tenantBSession = sessionStore.load(key2);
-        expect(tenantBSession).toBeDefined();
-    });
-    // ── purgeArchives ────────────────────────────────────────────────
-    it("purgeArchives removes expired archives", async () => {
-        sessionStore.save(testKey, [{ role: "user", content: "hello" }]);
-        const longAgo = Date.now() - 10 * 60 * 60 * 1000;
-        db.prepare("UPDATE sessions SET updated_at = ? WHERE session_key = ?").run(longAgo, "default:user-1:telegram");
-        // Compact with very short retention so archive expires immediately
-        await compactionService.compact({
-            minIdleMs: 1000,
-            archiveRetentionMs: 1, // 1ms retention
-        });
-        // Verify archive exists
-        const beforePurge = db.prepare("SELECT COUNT(*) as cnt FROM archives").get();
-        expect(beforePurge.cnt).toBe(1);
-        // Wait a tick to ensure expiry
-        await new Promise((r) => setTimeout(r, 10));
-        const purged = compactionService.purgeArchives();
-        expect(purged).toBe(1);
-        const afterPurge = db.prepare("SELECT COUNT(*) as cnt FROM archives").get();
-        expect(afterPurge.cnt).toBe(0);
-    });
-    it("purgeArchives does not remove non-expired archives", async () => {
-        sessionStore.save(testKey, [{ role: "user", content: "hello" }]);
-        const longAgo = Date.now() - 10 * 60 * 60 * 1000;
-        db.prepare("UPDATE sessions SET updated_at = ? WHERE session_key = ?").run(longAgo, "default:user-1:telegram");
-        // Compact with long retention
-        await compactionService.compact({
-            minIdleMs: 1000,
-            archiveRetentionMs: 7 * 24 * 60 * 60 * 1000, // 7 days
-        });
-        const purged = compactionService.purgeArchives();
-        expect(purged).toBe(0);
-        const archiveCount = db.prepare("SELECT COUNT(*) as cnt FROM archives").get();
-        expect(archiveCount.cnt).toBe(1);
-    });
-    it("purgeArchives returns 0 when no archives exist", () => {
-        const purged = compactionService.purgeArchives();
-        expect(purged).toBe(0);
-    });
-    // ── Empty session edge case ────────────────────────────────────
-    it("handles compaction with empty sessions (0 messages) without calling summarizer", async () => {
-        // Create a tracking summarizer that should never be called
-        const tracker = trackingSummarizer();
-        const service = createCompactionService(db, sessionStore, adapter, tracker);
-        // Save a session with 0 messages and make it stale
-        sessionStore.save(testKey, []);
-        const longAgo = Date.now() - 10 * 60 * 60 * 1000;
-        db.prepare("UPDATE sessions SET updated_at = ? WHERE session_key = ?").run(longAgo, "default:user-1:telegram");
-        const result = await service.compact({ minIdleMs: 1000 });
-        // Verify compaction completed successfully (no crash)
-        expect(result.sessionsCompacted).toBe(0);
-        expect(result.episodicCreated).toBe(0);
-        expect(result.factsExtracted).toBe(0);
-        expect(result.compactedKeys).toHaveLength(0);
-        // Summarizer should never have been called for an empty session
-        expect(tracker.callCount).toBe(0);
-        // No episodic or semantic memories should have been created
-        const episodic = db
-            .prepare("SELECT * FROM memories WHERE memory_type = 'episodic'")
-            .all();
-        expect(episodic).toHaveLength(0);
-        const semantic = db
-            .prepare("SELECT * FROM memories WHERE memory_type = 'semantic' AND tags LIKE '%fact%'")
-            .all();
-        expect(semantic).toHaveLength(0);
-    });
-    // ── Return value ─────────────────────────────────────────────────
-    it("returns empty result when no sessions are stale", async () => {
-        const result = await compactionService.compact({ minIdleMs: 1000 });
-        expect(result).toEqual({
-            sessionsCompacted: 0,
-            episodicCreated: 0,
-            factsExtracted: 0,
-            compactedKeys: [],
-        });
-    });
-});

package/node_modules/@comis/memory/dist/context-schema.test.d.ts

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

package/node_modules/@comis/memory/dist/context-schema.test.js

@@ -1,246 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import Database from "better-sqlite3";
-import { initContextSchema } from "./context-schema.js";
-/** Open an in-memory database with foreign keys enabled and schema initialized. */
-function createTestDb() {
-    const db = new Database(":memory:");
-    db.pragma("foreign_keys = ON");
-    initContextSchema(db);
-    return db;
-}
-/** Insert a minimal conversation row and return its id. */
-function insertConversation(db, id = "conv-1") {
-    db.prepare(`INSERT INTO ctx_conversations (conversation_id, tenant_id, agent_id, session_key)
-     VALUES (?, 'tenant-1', 'agent-1', ?)`).run(id, `session-${id}`);
-    return id;
-}
-/** Insert a minimal message row and return its message_id. */
-function insertMessage(db, conversationId, seq, role = "user", content = "hello") {
-    const info = db
-        .prepare(`INSERT INTO ctx_messages (conversation_id, seq, role, content, content_hash, token_count)
-       VALUES (?, ?, ?, ?, 'hash-' || ?, 1)`)
-        .run(conversationId, seq, role, content, seq);
-    return Number(info.lastInsertRowid);
-}
-/** Insert a minimal summary row and return its summary_id. */
-function insertSummary(db, summaryId, conversationId, kind = "leaf") {
-    db.prepare(`INSERT INTO ctx_summaries (summary_id, conversation_id, kind, content, token_count)
-     VALUES (?, ?, ?, 'summary content', 10)`).run(summaryId, conversationId, kind);
-    return summaryId;
-}
-describe("initContextSchema", () => {
-    let db;
-    beforeEach(() => {
-        db = createTestDb();
-    });
-    // --- Group 1: table creation ---
-    describe("table creation", () => {
-        it("creates all 9 regular ctx_ tables", () => {
-            // FTS5 creates shadow tables (e.g. ctx_messages_fts_content, _data, etc.)
-            // Filter them out by excluding names containing '_fts_' and the FTS5 virtual tables themselves.
-            const tables = db
-                .prepare(`SELECT name FROM sqlite_master
-           WHERE type='table' AND name LIKE 'ctx_%'
-             AND name NOT LIKE '%_fts%'
-           ORDER BY name`)
-                .all();
-            const names = tables.map((r) => r.name);
-            expect(names).toEqual([
-                "ctx_context_items",
-                "ctx_conversations",
-                "ctx_expansion_grants",
-                "ctx_large_files",
-                "ctx_message_parts",
-                "ctx_messages",
-                "ctx_summaries",
-                "ctx_summary_messages",
-                "ctx_summary_parents",
-            ]);
-        });
-        it("creates 2 FTS5 virtual tables", () => {
-            const fts = db
-                .prepare(`SELECT name FROM sqlite_master
-           WHERE sql LIKE '%fts5%' AND name LIKE 'ctx_%'
-           ORDER BY name`)
-                .all();
-            const names = fts.map((r) => r.name);
-            expect(names).toEqual(["ctx_messages_fts", "ctx_summaries_fts"]);
-        });
-        it("creates all expected indexes", () => {
-            const indexes = db
-                .prepare(`SELECT name FROM sqlite_master
-           WHERE type='index' AND name LIKE 'ctx_%'
-           ORDER BY name`)
-                .all();
-            const names = indexes.map((r) => r.name);
-            expect(names).toContain("ctx_messages_conv_seq");
-            expect(names).toContain("ctx_messages_hash");
-            expect(names).toContain("ctx_summaries_conv");
-            expect(names).toContain("ctx_summaries_depth");
-            expect(names).toContain("ctx_large_files_conv");
-            expect(names).toContain("ctx_large_files_hash");
-            expect(names).toContain("ctx_grants_session");
-            expect(names).toContain("ctx_grants_expires");
-        });
-    });
-    // --- Group 2: idempotency ---
-    describe("idempotency", () => {
-        it("calling initContextSchema twice produces no errors", () => {
-            // db already had initContextSchema called in createTestDb
-            expect(() => initContextSchema(db)).not.toThrow();
-            // Verify tables still exist and are usable
-            const convId = insertConversation(db);
-            insertMessage(db, convId, 1);
-            const count = db
-                .prepare("SELECT COUNT(*) as c FROM ctx_messages")
-                .get();
-            expect(count.c).toBe(1);
-        });
-    });
-    // --- Group 3: constraints ---
-    describe("constraints", () => {
-        it("ctx_messages role CHECK constraint rejects invalid roles", () => {
-            const convId = insertConversation(db);
-            expect(() => {
-                db.prepare(`INSERT INTO ctx_messages (conversation_id, seq, role, content, content_hash, token_count)
-           VALUES (?, 1, 'invalid', 'test', 'hash', 1)`).run(convId);
-            }).toThrow();
-        });
-        it("ctx_messages role CHECK allows valid roles", () => {
-            const convId = insertConversation(db);
-            for (const [i, role] of ["system", "user", "assistant", "tool"].entries()) {
-                expect(() => {
-                    db.prepare(`INSERT INTO ctx_messages (conversation_id, seq, role, content, content_hash, token_count)
-             VALUES (?, ?, ?, 'content', 'hash-' || ?, 1)`).run(convId, i + 1, role, i);
-                }).not.toThrow();
-            }
-        });
-        it("ctx_messages UNIQUE(conversation_id, seq) prevents duplicates", () => {
-            const convId = insertConversation(db);
-            insertMessage(db, convId, 1);
-            expect(() => insertMessage(db, convId, 1)).toThrow();
-        });
-        it("ctx_summaries kind CHECK constraint rejects invalid kinds", () => {
-            const convId = insertConversation(db);
-            expect(() => {
-                db.prepare(`INSERT INTO ctx_summaries (summary_id, conversation_id, kind, content, token_count)
-           VALUES ('s1', ?, 'invalid', 'content', 10)`).run(convId);
-            }).toThrow();
-        });
-        it("ctx_context_items CHECK enforces item_type exclusivity", () => {
-            const convId = insertConversation(db);
-            const msgId = insertMessage(db, convId, 1);
-            const sumId = insertSummary(db, "sum-1", convId);
-            // item_type='message' with summary_id set -- should fail
-            expect(() => {
-                db.prepare(`INSERT INTO ctx_context_items (conversation_id, ordinal, item_type, message_id, summary_id)
-           VALUES (?, 1, 'message', ?, ?)`).run(convId, msgId, sumId);
-            }).toThrow();
-            // item_type='summary' with message_id set -- should fail
-            expect(() => {
-                db.prepare(`INSERT INTO ctx_context_items (conversation_id, ordinal, item_type, message_id, summary_id)
-           VALUES (?, 2, 'summary', ?, ?)`).run(convId, msgId, sumId);
-            }).toThrow();
-            // Valid: message item with only message_id
-            expect(() => {
-                db.prepare(`INSERT INTO ctx_context_items (conversation_id, ordinal, item_type, message_id, summary_id)
-           VALUES (?, 1, 'message', ?, NULL)`).run(convId, msgId);
-            }).not.toThrow();
-            // Valid: summary item with only summary_id
-            expect(() => {
-                db.prepare(`INSERT INTO ctx_context_items (conversation_id, ordinal, item_type, message_id, summary_id)
-           VALUES (?, 2, 'summary', NULL, ?)`).run(convId, sumId);
-            }).not.toThrow();
-        });
-        it("ctx_messages AUTOINCREMENT prevents rowid reuse", () => {
-            const convId = insertConversation(db);
-            insertMessage(db, convId, 1); // message_id = 1
-            insertMessage(db, convId, 2); // message_id = 2
-            const thirdId = insertMessage(db, convId, 3); // message_id = 3
-            expect(thirdId).toBe(3);
-            // Delete the last message
-            db.prepare("DELETE FROM ctx_messages WHERE message_id = ?").run(thirdId);
-            // Insert a new message -- must get id=4, not 3 (AUTOINCREMENT)
-            const fourthId = insertMessage(db, convId, 3, "user", "new content");
-            expect(fourthId).toBe(4);
-        });
-    });
-    // --- Group 4: foreign keys and cascades ---
-    describe("foreign keys and cascades", () => {
-        it("deleting a conversation cascades to messages", () => {
-            const convId = insertConversation(db);
-            insertMessage(db, convId, 1);
-            insertMessage(db, convId, 2);
-            db.prepare("DELETE FROM ctx_conversations WHERE conversation_id = ?").run(convId);
-            const count = db
-                .prepare("SELECT COUNT(*) as c FROM ctx_messages")
-                .get();
-            expect(count.c).toBe(0);
-        });
-        it("deleting a conversation cascades to summaries and context_items", () => {
-            const convId = insertConversation(db);
-            const msgId = insertMessage(db, convId, 1);
-            insertSummary(db, "sum-1", convId);
-            db.prepare(`INSERT INTO ctx_context_items (conversation_id, ordinal, item_type, message_id, summary_id)
-         VALUES (?, 1, 'message', ?, NULL)`).run(convId, msgId);
-            db.prepare("DELETE FROM ctx_conversations WHERE conversation_id = ?").run(convId);
-            const sumCount = db
-                .prepare("SELECT COUNT(*) as c FROM ctx_summaries")
-                .get();
-            const itemCount = db
-                .prepare("SELECT COUNT(*) as c FROM ctx_context_items")
-                .get();
-            expect(sumCount.c).toBe(0);
-            expect(itemCount.c).toBe(0);
-        });
-        it("cannot delete a message referenced by ctx_summary_messages (RESTRICT)", () => {
-            const convId = insertConversation(db);
-            const msgId = insertMessage(db, convId, 1);
-            insertSummary(db, "sum-1", convId);
-            db.prepare(`INSERT INTO ctx_summary_messages (summary_id, message_id, ordinal)
-         VALUES ('sum-1', ?, 0)`).run(msgId);
-            expect(() => {
-                db.prepare("DELETE FROM ctx_messages WHERE message_id = ?").run(msgId);
-            }).toThrow();
-        });
-        it("cannot delete a parent summary referenced by ctx_summary_parents (RESTRICT)", () => {
-            const convId = insertConversation(db);
-            const parentId = insertSummary(db, "sum-parent", convId, "leaf");
-            const childId = insertSummary(db, "sum-child", convId, "condensed");
-            db.prepare(`INSERT INTO ctx_summary_parents (summary_id, parent_summary_id, ordinal)
-         VALUES (?, ?, 0)`).run(childId, parentId);
-            expect(() => {
-                db.prepare("DELETE FROM ctx_summaries WHERE summary_id = ?").run(parentId);
-            }).toThrow();
-        });
-    });
-    // --- Group 5: FTS5 standalone tables ---
-    describe("FTS5 standalone tables", () => {
-        it("can insert and query ctx_messages_fts", () => {
-            db.prepare("INSERT INTO ctx_messages_fts(rowid, content) VALUES (1, 'the quick brown fox')").run();
-            const results = db
-                .prepare("SELECT rowid, content FROM ctx_messages_fts WHERE ctx_messages_fts MATCH 'brown'")
-                .all();
-            expect(results).toHaveLength(1);
-            expect(results[0].rowid).toBe(1);
-            expect(results[0].content).toBe("the quick brown fox");
-        });
-        it("can insert and query ctx_summaries_fts", () => {
-            db.prepare("INSERT INTO ctx_summaries_fts(summary_id, content) VALUES ('sum-1', 'summary of important events')").run();
-            const results = db
-                .prepare("SELECT summary_id, content FROM ctx_summaries_fts WHERE content MATCH 'important'")
-                .all();
-            expect(results).toHaveLength(1);
-            expect(results[0].summary_id).toBe("sum-1");
-            expect(results[0].content).toBe("summary of important events");
-        });
-        it("FTS5 uses porter tokenizer", () => {
-            // "running" should stem to "run" via porter tokenizer
-            db.prepare("INSERT INTO ctx_messages_fts(rowid, content) VALUES (1, 'running quickly')").run();
-            const results = db
-                .prepare("SELECT rowid FROM ctx_messages_fts WHERE ctx_messages_fts MATCH 'run'")
-                .all();
-            expect(results).toHaveLength(1);
-        });
-    });
-});

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

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