chapterhouse 0.3.12 → 0.3.14

package/dist/store/squad-sessions.test.js

@@ -1,341 +0,0 @@
-/**
- * Phase 4 — DB + orchestrator session isolation tests
- *
- * Covers:
- *  - copilot_sessions table creation
- *  - conversation_log.session_key migration
- *  - upsertCopilotSession / getCopilotSession roundtrip
- *  - default session key semantics
- *  - project session isolation
- *  - session key derivation via normalizeProjectPath
- */
-import assert from "node:assert/strict";
-import { mkdirSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import test from "node:test";
-import Database from "better-sqlite3";
-const repoRoot = process.cwd();
-const sandboxRoot = join(repoRoot, ".test-work", `squad-sessions-${process.pid}`);
-const chapterhouseHome = join(sandboxRoot, ".chapterhouse");
-const dbPath = join(chapterhouseHome, "chapterhouse.db");
-process.env.CHAPTERHOUSE_HOME = sandboxRoot;
-async function loadDbModule() {
-    return await import(new URL(`./db.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
-}
-async function loadContextModule() {
-    return await import(new URL(`../squad/context.js?v=${Date.now()}-${Math.random()}`, import.meta.url).href);
-}
-function resetSandbox() {
-    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
-    rmSync(sandboxRoot, { recursive: true, force: true });
-    mkdirSync(chapterhouseHome, { recursive: true });
-}
-test.beforeEach(() => {
-    resetSandbox();
-});
-test.after(() => {
-    rmSync(sandboxRoot, { recursive: true, force: true });
-});
-// ---------------------------------------------------------------------------
-// 1. copilot_sessions table exists after getDb()
-// ---------------------------------------------------------------------------
-test("copilot_sessions table exists with correct schema after getDb()", async () => {
-    const dbModule = await loadDbModule();
-    try {
-        const db = dbModule.getDb();
-        const tables = db.prepare(`SELECT name FROM sqlite_master WHERE type = 'table'`).all();
-        const tableNames = new Set(tables.map((row) => row.name));
-        assert.equal(tableNames.has("copilot_sessions"), true, "copilot_sessions table should exist");
-        // Verify columns
-        const cols = db.prepare(`PRAGMA table_info(copilot_sessions)`).all();
-        const colMap = new Map(cols.map((c) => [c.name, c]));
-        assert.equal(colMap.has("session_key"), true, "should have session_key column");
-        assert.equal(colMap.has("mode"), true, "should have mode column");
-        assert.equal(colMap.has("project_root"), true, "should have project_root column");
-        assert.equal(colMap.has("copilot_session_id"), true, "should have copilot_session_id column");
-        assert.equal(colMap.has("model"), true, "should have model column");
-        assert.equal(colMap.has("updated_at"), true, "should have updated_at column");
-        // session_key is PRIMARY KEY
-        assert.equal(colMap.get("session_key")?.pk, 1, "session_key should be primary key");
-        // mode is NOT NULL
-        assert.equal(colMap.get("mode")?.notnull, 1, "mode should be NOT NULL");
-        // copilot_session_id is NOT NULL
-        assert.equal(colMap.get("copilot_session_id")?.notnull, 1, "copilot_session_id should be NOT NULL");
-    }
-    finally {
-        dbModule.closeDb();
-    }
-});
-// ---------------------------------------------------------------------------
-// 2. conversation_log has session_key column
-// ---------------------------------------------------------------------------
-test("conversation_log has session_key column with default 'default'", async () => {
-    const dbModule = await loadDbModule();
-    try {
-        dbModule.getDb();
-        const db = new Database(dbPath, { readonly: true });
-        const cols = db.prepare(`PRAGMA table_info(conversation_log)`).all();
-        db.close();
-        const sessionKeyCol = cols.find((c) => c.name === "session_key");
-        assert.ok(sessionKeyCol, "conversation_log should have a session_key column");
-        assert.match(sessionKeyCol.dflt_value ?? "", /default/i, `session_key default should be 'default', got: ${sessionKeyCol.dflt_value}`);
-    }
-    finally {
-        dbModule.closeDb();
-    }
-});
-// ---------------------------------------------------------------------------
-// 3. upsertCopilotSession + getCopilotSession roundtrip
-// ---------------------------------------------------------------------------
-test("upsertCopilotSession and getCopilotSession roundtrip preserves all fields", async () => {
-    const dbModule = await loadDbModule();
-    try {
-        dbModule.getDb();
-        assert.equal(typeof dbModule.upsertCopilotSession, "function", "upsertCopilotSession should be exported from db module");
-        assert.equal(typeof dbModule.getCopilotSession, "function", "getCopilotSession should be exported from db module");
-        dbModule.upsertCopilotSession("project:/home/user/myrepo", "project", "sdk-abc-123", "/home/user/myrepo", "gpt-4.1");
-        const row = dbModule.getCopilotSession("project:/home/user/myrepo");
-        assert.ok(row, "getCopilotSession should return a row for the upserted key");
-        assert.equal(row.copilotSessionId, "sdk-abc-123");
-        assert.equal(row.model, "gpt-4.1");
-    }
-    finally {
-        dbModule.closeDb();
-    }
-});
-// ---------------------------------------------------------------------------
-// 4. Default session uses 'default' key
-// ---------------------------------------------------------------------------
-test("logConversation without session_key defaults to 'default' session", async () => {
-    const dbModule = await loadDbModule();
-    try {
-        const db = dbModule.getDb();
-        // logConversation existing signature — should log to 'default' session
-        dbModule.logConversation("user", "Hello world", "web");
-        const rows = db.prepare(`SELECT session_key FROM conversation_log WHERE content = 'Hello world'`).all();
-        assert.equal(rows.length, 1, "should have logged one row");
-        assert.equal(rows[0].session_key, "default", "session_key should default to 'default'");
-    }
-    finally {
-        dbModule.closeDb();
-    }
-});
-// ---------------------------------------------------------------------------
-// 5. Project sessions are isolated
-// ---------------------------------------------------------------------------
-test("conversation_log rows for project:a do not appear in project:b query", async () => {
-    const dbModule = await loadDbModule();
-    try {
-        const db = dbModule.getDb();
-        // Verify logConversation accepts an optional session_key param
-        const log = dbModule.logConversation;
-        log("user", "Message in project A", "web", "project:/repo/a");
-        log("user", "Message in project B", "web", "project:/repo/b");
-        log("user", "Default message", "web");
-        const projectARows = db.prepare(`SELECT content FROM conversation_log WHERE session_key = 'project:/repo/a'`).all();
-        const projectBRows = db.prepare(`SELECT content FROM conversation_log WHERE session_key = 'project:/repo/b'`).all();
-        const defaultRows = db.prepare(`SELECT content FROM conversation_log WHERE session_key = 'default'`).all();
-        assert.equal(projectARows.length, 1, "project A should have exactly 1 row");
-        assert.equal(projectARows[0].content, "Message in project A");
-        assert.equal(projectBRows.length, 1, "project B should have exactly 1 row");
-        assert.equal(projectBRows[0].content, "Message in project B");
-        assert.equal(defaultRows.length, 1, "default session should have exactly 1 row");
-        assert.equal(defaultRows[0].content, "Default message");
-    }
-    finally {
-        dbModule.closeDb();
-    }
-});
-// ---------------------------------------------------------------------------
-// 6. Session key derivation — normalizeProjectPath is consistent
-// ---------------------------------------------------------------------------
-test("projectSessionKey format uses normalizeProjectPath for consistency", async () => {
-    const context = await loadContextModule();
-    // normalizeProjectPath must exist
-    assert.equal(typeof context.normalizeProjectPath, "function", "normalizeProjectPath should be exported from context module");
-    const normalized = context.normalizeProjectPath("/home/user/myrepo");
-    const sessionKey = `project:${normalized}`;
-    assert.match(sessionKey, /^project:\//, "session key should start with 'project:/'");
-    assert.equal(sessionKey, `project:${normalized}`, "session key should be project:${normalizedPath}");
-    // Home-relative paths must normalize to the same value as absolute
-    const fromHome = context.normalizeProjectPath("~/myrepo");
-    const fromHomeKey = `project:${fromHome}`;
-    assert.match(fromHomeKey, /^project:\//, "home-relative path should also produce absolute session key");
-    // Two calls with same path produce same key
-    const key1 = `project:${context.normalizeProjectPath("/some/project")}`;
-    const key2 = `project:${context.normalizeProjectPath("/some/project")}`;
-    assert.equal(key1, key2, "session key must be deterministic for the same path");
-});
-// ---------------------------------------------------------------------------
-// 7. Backfill: existing conversation_log rows get session_key = 'default'
-// ---------------------------------------------------------------------------
-test("migration backfills existing conversation_log rows to session_key='default'", async () => {
-    // Pre-seed a DB without session_key column (simulating pre-migration state)
-    const seedDb = new Database(dbPath);
-    seedDb.exec(`
-    CREATE TABLE conversation_log (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      role TEXT NOT NULL CHECK(role IN ('user', 'assistant', 'system')),
-      content TEXT NOT NULL,
-      source TEXT NOT NULL DEFAULT 'unknown',
-      ts DATETIME DEFAULT CURRENT_TIMESTAMP
-    )
-  `);
-    seedDb.prepare(`INSERT INTO conversation_log (role, content, source) VALUES (?, ?, ?)`).run("user", "Old turn", "cli");
-    seedDb.close();
-    const dbModule = await loadDbModule();
-    try {
-        dbModule.getDb();
-        const db = new Database(dbPath, { readonly: true });
-        const rows = db.prepare(`SELECT session_key FROM conversation_log WHERE content = 'Old turn'`).all();
-        db.close();
-        assert.equal(rows.length, 1, "backfilled row should exist");
-        assert.equal(rows[0].session_key, "default", "backfilled row should have session_key='default'");
-    }
-    finally {
-        dbModule.closeDb();
-    }
-});
-// ---------------------------------------------------------------------------
-// 8. getCopilotSession returns undefined for unknown key
-// ---------------------------------------------------------------------------
-test("getCopilotSession returns undefined for an unknown session key", async () => {
-    const dbModule = await loadDbModule();
-    try {
-        dbModule.getDb();
-        const result = dbModule.getCopilotSession("project:/nonexistent/path");
-        assert.equal(result, undefined, "should return undefined for unknown session");
-    }
-    finally {
-        dbModule.closeDb();
-    }
-});
-// ---------------------------------------------------------------------------
-// 9. agent_tasks table has session_key column
-// ---------------------------------------------------------------------------
-test("agent_tasks table has session_key column for task routing", async () => {
-    const dbModule = await loadDbModule();
-    try {
-        const db = dbModule.getDb();
-        const cols = db.prepare(`PRAGMA table_info(agent_tasks)`).all();
-        const colNames = new Set(cols.map((c) => c.name));
-        assert.equal(colNames.has("session_key"), true, "agent_tasks should have a session_key column for routing completions back to originating session");
-    }
-    finally {
-        dbModule.closeDb();
-    }
-});
-// ---------------------------------------------------------------------------
-// 10. getRecentConversation(sessionKey) filters to one session only
-// ---------------------------------------------------------------------------
-test("getRecentConversation with sessionKey returns only rows for that session", async () => {
-    const dbModule = await loadDbModule();
-    try {
-        dbModule.getDb();
-        // Write rows to two different sessions
-        dbModule.logConversation("user", "Squad project question", "web", "project:/repo/squad");
-        dbModule.logConversation("assistant", "Squad project answer", "web", "project:/repo/squad");
-        dbModule.logConversation("user", "Default chat question", "web", "default");
-        // Scoped read — only project:/repo/squad rows
-        const squadHistory = dbModule.getRecentConversation(20, "project:/repo/squad");
-        assert.ok(squadHistory.includes("Squad project question"), "should include squad session user turn");
-        assert.ok(squadHistory.includes("Squad project answer"), "should include squad session assistant turn");
-        assert.ok(!squadHistory.includes("Default chat question"), "should NOT include default session rows");
-        // Scoped read — only default session rows
-        const defaultHistory = dbModule.getRecentConversation(20, "default");
-        assert.ok(defaultHistory.includes("Default chat question"), "should include default session row");
-        assert.ok(!defaultHistory.includes("Squad project question"), "should NOT include squad session rows");
-        // No sessionKey — cross-session (legacy behavior)
-        const allHistory = dbModule.getRecentConversation(20);
-        assert.ok(allHistory.includes("Squad project question"), "unscoped read should include all sessions");
-        assert.ok(allHistory.includes("Default chat question"), "unscoped read should include all sessions");
-    }
-    finally {
-        dbModule.closeDb();
-    }
-});
-// ---------------------------------------------------------------------------
-// 11. getRecentConversation with sessionKey that has no rows returns ""
-// ---------------------------------------------------------------------------
-test("getRecentConversation with sessionKey for empty session returns empty string", async () => {
-    const dbModule = await loadDbModule();
-    try {
-        dbModule.getDb();
-        // Write rows only to 'default'
-        dbModule.logConversation("user", "Default only message", "web", "default");
-        // Scoped read for a session that has no rows
-        const emptyHistory = dbModule.getRecentConversation(20, "project:/repo/empty");
-        assert.equal(emptyHistory, "", "scoped read for a session with no rows should return empty string");
-    }
-    finally {
-        dbModule.closeDb();
-    }
-});
-// ---------------------------------------------------------------------------
-// 12. getRecentConversation with unknown sessionKey returns "" not other rows
-// ---------------------------------------------------------------------------
-test("getRecentConversation with unrecognized sessionKey does not bleed rows from other sessions", async () => {
-    const dbModule = await loadDbModule();
-    try {
-        dbModule.getDb();
-        dbModule.logConversation("user", "Session A content", "web", "project:/repo/a");
-        dbModule.logConversation("user", "Default content", "web", "default");
-        // An entirely different sessionKey that has never been written to
-        const ghost = dbModule.getRecentConversation(20, "project:/repo/ghost");
-        assert.equal(ghost, "", "unrecognized sessionKey should return '' not bleed other sessions' rows");
-    }
-    finally {
-        dbModule.closeDb();
-    }
-});
-// ---------------------------------------------------------------------------
-// 13. getTaskSessionKey returns 'default' for an unknown task_id
-// ---------------------------------------------------------------------------
-test("getTaskSessionKey returns 'default' for an unknown task_id", async () => {
-    const dbModule = await loadDbModule();
-    try {
-        dbModule.getDb();
-        const key = dbModule.getTaskSessionKey("nonexistent-task-xyz");
-        assert.equal(key, "default", "unknown task_id should return fallback 'default'");
-    }
-    finally {
-        dbModule.closeDb();
-    }
-});
-// ---------------------------------------------------------------------------
-// 14. getTaskSessionKey falls back to 'default' on legacy schema (no session_key column)
-// ---------------------------------------------------------------------------
-test("getTaskSessionKey falls back to 'default' when session_key column is absent (legacy schema)", async () => {
-    const dbModule = await loadDbModule();
-    try {
-        // Initialize the module (migrations run, session_key column added)
-        dbModule.getDb();
-        // Insert a task without session_key through the already-open connection
-        const db = dbModule.getDb();
-        db.exec(`INSERT INTO agent_tasks (task_id, agent_slug, description, status) VALUES ('legacy-task-z', 'coder', 'Do work', 'done')`);
-        // Drop and recreate agent_tasks WITHOUT the session_key column while the module
-        // holds a reference — this simulates a legacy schema that the try/catch must handle.
-        db.exec(`ALTER TABLE agent_tasks RENAME TO agent_tasks_bk`);
-        db.exec(`
-      CREATE TABLE agent_tasks (
-        task_id TEXT PRIMARY KEY,
-        agent_slug TEXT NOT NULL,
-        description TEXT NOT NULL,
-        status TEXT NOT NULL DEFAULT 'running',
-        result TEXT,
-        origin_channel TEXT,
-        started_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-        completed_at DATETIME
-      )
-    `);
-        db.exec(`INSERT INTO agent_tasks SELECT task_id, agent_slug, description, status, result, origin_channel, started_at, completed_at FROM agent_tasks_bk`);
-        db.exec(`DROP TABLE agent_tasks_bk`);
-        // Now getTaskSessionKey must fall back because session_key column doesn't exist
-        const key = dbModule.getTaskSessionKey("legacy-task-z");
-        assert.equal(key, "default", "getTaskSessionKey should return 'default' when session_key column is absent");
-    }
-    finally {
-        dbModule.closeDb();
-    }
-});
-//# sourceMappingURL=squad-sessions.test.js.map