@codexa/cli 9.0.31 → 9.0.32

package/commands/knowledge.test.ts

@@ -1,6 +1,7 @@
-import { describe, it, expect, beforeEach } from "bun:test";
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
 import { jaccardSimilarity, compactKnowledge } from "./knowledge";
-import { getDb } from "../db/connection";
+import { createClient } from "@libsql/client";
+import { setClient, resetClient, dbGet, dbAll, dbRun } from "../db/connection";
 import { initSchema } from "../db/schema";
 import { cleanDb } from "../db/test-helpers";
 
@@ -34,9 +35,7 @@ describe("jaccardSimilarity", () => {
   });
 
   it("ignores short words (<=2 chars)", () => {
-    // "a" and "is" are filtered out, only "cat" and "dog" matter
     const sim = jaccardSimilarity("a cat is here", "a dog is here");
-    // "cat" vs "dog" + "here" in common
     expect(sim).toBeGreaterThan(0);
     expect(sim).toBeLessThan(1);
   });
@@ -48,108 +47,104 @@ describe("jaccardSimilarity", () => {
 });
 
 describe("compactKnowledge", () => {
-  beforeEach(() => {
-    initSchema();
-    cleanDb();
+  beforeEach(async () => {
+    const client = createClient({ url: ":memory:" });
+    setClient(client);
+    await initSchema();
+    await cleanDb();
   });
 
-  function createSpec(id: string, phase: string) {
-    const db = getDb();
+  afterEach(() => {
+    resetClient();
+  });
+
+  async function createSpec(id: string, phase: string) {
     const now = new Date().toISOString();
-    db.run(
+    await dbRun(
       "INSERT INTO specs (id, name, phase, created_at, updated_at) VALUES (?, ?, ?, ?, ?)",
       [id, `Feature ${id}`, phase, now, now]
     );
   }
 
-  function addKnowledgeEntry(specId: string, content: string, category: string, severity: string, createdAt?: string) {
-    const db = getDb();
+  async function addKnowledgeEntry(specId: string, content: string, category: string, severity: string, createdAt?: string) {
     const now = createdAt || new Date().toISOString();
-    db.run(
+    await dbRun(
       `INSERT INTO knowledge (spec_id, task_origin, category, content, severity, broadcast_to, created_at)
        VALUES (?, 0, ?, ?, ?, 'all', ?)`,
       [specId, category, content, severity, now]
     );
   }
 
-  it("merges similar entries in same category and spec", () => {
-    createSpec("spec-a", "implementing");
-    addKnowledgeEntry("spec-a", "Implemented user authentication with JWT tokens for the login flow", "discovery", "info");
-    addKnowledgeEntry("spec-a", "Implemented user authentication with JWT tokens for login flow", "discovery", "info");
+  it("merges similar entries in same category and spec", async () => {
+    await createSpec("spec-a", "implementing");
+    await addKnowledgeEntry("spec-a", "Implemented user authentication with JWT tokens for the login flow", "discovery", "info");
+    await addKnowledgeEntry("spec-a", "Implemented user authentication with JWT tokens for login flow", "discovery", "info");
 
-    // Dry run first
-    compactKnowledge({ dryRun: true, json: true });
+    await compactKnowledge({ dryRun: true, json: true });
 
-    // Actual compact
-    compactKnowledge({ json: true });
+    await compactKnowledge({ json: true });
 
-    const db = getDb();
-    const archived = db.query("SELECT COUNT(*) as c FROM knowledge WHERE severity = 'archived'").get() as any;
+    const archived = await dbGet<any>("SELECT COUNT(*) as c FROM knowledge WHERE severity = 'archived'");
     expect(archived.c).toBe(1);
   });
 
-  it("keeps higher severity entry when merging", () => {
-    createSpec("spec-a", "implementing");
-    addKnowledgeEntry("spec-a", "Database connection timeout causing failures in production", "blocker", "critical");
-    addKnowledgeEntry("spec-a", "Database connection timeout causing failures in production system", "blocker", "info");
+  it("keeps higher severity entry when merging", async () => {
+    await createSpec("spec-a", "implementing");
+    await addKnowledgeEntry("spec-a", "Database connection timeout causing failures in production", "blocker", "critical");
+    await addKnowledgeEntry("spec-a", "Database connection timeout causing failures in production system", "blocker", "info");
 
-    compactKnowledge({ json: true });
+    await compactKnowledge({ json: true });
 
-    const db = getDb();
-    const remaining = db.query("SELECT * FROM knowledge WHERE severity != 'archived'").all() as any[];
+    const remaining = await dbAll<any>("SELECT * FROM knowledge WHERE severity != 'archived'");
     expect(remaining.length).toBe(1);
     expect(remaining[0].severity).toBe("critical");
   });
 
-  it("archives old info entries (>7 days)", () => {
-    createSpec("spec-a", "implementing");
+  it("archives old info entries (>7 days)", async () => {
+    await createSpec("spec-a", "implementing");
     const oldDate = new Date(Date.now() - 10 * 24 * 60 * 60 * 1000).toISOString();
-    addKnowledgeEntry("spec-a", "Some old discovery that is not referenced anywhere in the graph", "discovery", "info", oldDate);
-    addKnowledgeEntry("spec-a", "A recent discovery that should not be archived by this compaction", "discovery", "info");
+    await addKnowledgeEntry("spec-a", "Some old discovery that is not referenced anywhere in the graph", "discovery", "info", oldDate);
+    await addKnowledgeEntry("spec-a", "A recent discovery that should not be archived by this compaction", "discovery", "info");
 
-    compactKnowledge({ json: true });
+    await compactKnowledge({ json: true });
 
-    const db = getDb();
-    const archived = db.query("SELECT COUNT(*) as c FROM knowledge WHERE severity = 'archived'").get() as any;
+    const archived = await dbGet<any>("SELECT COUNT(*) as c FROM knowledge WHERE severity = 'archived'");
     expect(archived.c).toBe(1);
   });
 
-  it("archives entries from completed specs", () => {
-    createSpec("spec-done", "completed");
-    addKnowledgeEntry("spec-done", "Something learned during completed feature implementation", "discovery", "info");
-    addKnowledgeEntry("spec-done", "A critical blocker that was found during the implementation phase", "blocker", "critical");
+  it("archives entries from completed specs", async () => {
+    await createSpec("spec-done", "completed");
+    await addKnowledgeEntry("spec-done", "Something learned during completed feature implementation", "discovery", "info");
+    await addKnowledgeEntry("spec-done", "A critical blocker that was found during the implementation phase", "blocker", "critical");
 
-    compactKnowledge({ json: true });
+    await compactKnowledge({ json: true });
 
-    const db = getDb();
-    const archived = db.query("SELECT COUNT(*) as c FROM knowledge WHERE severity = 'archived'").get() as any;
+    const archived = await dbGet<any>("SELECT COUNT(*) as c FROM knowledge WHERE severity = 'archived'");
     expect(archived.c).toBe(2);
   });
 
-  it("dry-run mode does not modify DB", () => {
-    createSpec("spec-done", "completed");
-    addKnowledgeEntry("spec-done", "Something that would be archived in a real compaction run", "discovery", "info");
+  it("dry-run mode does not modify DB", async () => {
+    await createSpec("spec-done", "completed");
+    await addKnowledgeEntry("spec-done", "Something that would be archived in a real compaction run", "discovery", "info");
 
-    compactKnowledge({ dryRun: true, json: true });
+    await compactKnowledge({ dryRun: true, json: true });
 
-    const db = getDb();
-    const archived = db.query("SELECT COUNT(*) as c FROM knowledge WHERE severity = 'archived'").get() as any;
+    const archived = await dbGet<any>("SELECT COUNT(*) as c FROM knowledge WHERE severity = 'archived'");
     expect(archived.c).toBe(0);
   });
 
-  it("respects --spec filter", () => {
-    createSpec("spec-a", "implementing");
-    createSpec("spec-b", "implementing");
-    addKnowledgeEntry("spec-a", "Implemented user authentication with JWT tokens for the system", "discovery", "info");
-    addKnowledgeEntry("spec-a", "Implemented user authentication with JWT tokens for the system flow", "discovery", "info");
-    addKnowledgeEntry("spec-b", "Implemented user authentication with JWT tokens for the login", "discovery", "info");
-    addKnowledgeEntry("spec-b", "Implemented user authentication with JWT tokens for the login flow", "discovery", "info");
+  it("respects --spec filter", async () => {
+    await createSpec("spec-a", "implementing");
+    await createSpec("spec-b", "implementing");
+    await addKnowledgeEntry("spec-a", "Implemented user authentication with JWT tokens for the system", "discovery", "info");
+    await addKnowledgeEntry("spec-a", "Implemented user authentication with JWT tokens for the system flow", "discovery", "info");
+    await addKnowledgeEntry("spec-b", "Implemented user authentication with JWT tokens for the login", "discovery", "info");
+    await addKnowledgeEntry("spec-b", "Implemented user authentication with JWT tokens for the login flow", "discovery", "info");
 
-    compactKnowledge({ specId: "spec-a", json: true });
+    await compactKnowledge({ specId: "spec-a", json: true });
 
-    const db = getDb();
-    const archivedA = db.query("SELECT COUNT(*) as c FROM knowledge WHERE severity = 'archived' AND spec_id = 'spec-a'").get() as any;
-    const archivedB = db.query("SELECT COUNT(*) as c FROM knowledge WHERE severity = 'archived' AND spec_id = 'spec-b'").get() as any;
+    const archivedA = await dbGet<any>("SELECT COUNT(*) as c FROM knowledge WHERE severity = 'archived' AND spec_id = 'spec-a'");
+    const archivedB = await dbGet<any>("SELECT COUNT(*) as c FROM knowledge WHERE severity = 'archived' AND spec_id = 'spec-b'");
     expect(archivedA.c).toBe(1);
     expect(archivedB.c).toBe(0);
   });