chapterhouse 0.13.0 → 0.14.0

package/dist/memory/scopes.js

@@ -1,89 +0,0 @@
-import { getDb } from "../store/db.js";
-function parseKeywords(raw, scopeSlug) {
-    const parsed = JSON.parse(raw);
-    if (!Array.isArray(parsed) || parsed.some((value) => typeof value !== "string")) {
-        throw new Error(`Invalid mem_scopes.keywords payload for scope '${scopeSlug}'.`);
-    }
-    return parsed;
-}
-function serializeKeywords(keywords) {
-    if (!Array.isArray(keywords) || keywords.some((keyword) => typeof keyword !== "string")) {
-        throw new Error("Scope keywords must be an array of strings.");
-    }
-    return JSON.stringify(keywords);
-}
-function toScope(row) {
-    return {
-        id: row.id,
-        slug: row.slug,
-        title: row.title,
-        description: row.description,
-        keywords: parseKeywords(row.keywords, row.slug),
-        active: row.active === 1,
-        createdAt: row.created_at,
-        updatedAt: row.updated_at,
-    };
-}
-function getScopeRow(idOrSlug) {
-    const db = getDb();
-    if (typeof idOrSlug === "number") {
-        return db.prepare(`
-      SELECT id, slug, title, description, keywords, active, created_at, updated_at
-      FROM mem_scopes
-      WHERE id = ?
-    `).get(idOrSlug);
-    }
-    return db.prepare(`
-    SELECT id, slug, title, description, keywords, active, created_at, updated_at
-    FROM mem_scopes
-    WHERE slug = ?
-  `).get(idOrSlug);
-}
-export function listScopes() {
-    const db = getDb();
-    const rows = db.prepare(`
-    SELECT id, slug, title, description, keywords, active, created_at, updated_at
-    FROM mem_scopes
-    ORDER BY slug
-  `).all();
-    return rows.map(toScope);
-}
-export function getScope(idOrSlug) {
-    const row = getScopeRow(idOrSlug);
-    return row ? toScope(row) : undefined;
-}
-export function createScope(input) {
-    const db = getDb();
-    const result = db.prepare(`
-    INSERT INTO mem_scopes (slug, title, description, keywords, active, created_at, updated_at)
-    VALUES (?, ?, ?, ?, 1, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
-  `).run(input.slug, input.title, input.description, serializeKeywords(input.keywords));
-    return getScope(Number(result.lastInsertRowid));
-}
-export function updateScope(id, patch) {
-    const existing = getScope(id);
-    if (!existing) {
-        throw new Error(`Unknown scope id '${id}'.`);
-    }
-    const nextTitle = patch.title ?? existing.title;
-    const nextDescription = patch.description ?? existing.description;
-    const nextKeywords = patch.keywords ?? existing.keywords;
-    getDb().prepare(`
-    UPDATE mem_scopes
-    SET title = ?, description = ?, keywords = ?, updated_at = CURRENT_TIMESTAMP
-    WHERE id = ?
-  `).run(nextTitle, nextDescription, serializeKeywords(nextKeywords), id);
-    return getScope(id);
-}
-export function deactivateScope(id) {
-    const result = getDb().prepare(`
-    UPDATE mem_scopes
-    SET active = 0, updated_at = CURRENT_TIMESTAMP
-    WHERE id = ?
-  `).run(id);
-    if (result.changes === 0) {
-        throw new Error(`Unknown scope id '${id}'.`);
-    }
-    return getScope(id);
-}
-//# sourceMappingURL=scopes.js.map

package/dist/memory/scopes.test.js

@@ -1,176 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdirSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import test from "node:test";
-const repoRoot = process.cwd();
-const sandboxRoot = join(repoRoot, ".test-work", `memory-scopes-${process.pid}`);
-const chapterhouseHome = join(sandboxRoot, ".chapterhouse");
-process.env.CHAPTERHOUSE_HOME = sandboxRoot;
-async function loadModules() {
-    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
-    const memoryModule = await import(new URL("./scopes.js", import.meta.url).href);
-    return { dbModule, memoryModule };
-}
-function resetSandbox() {
-    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
-    rmSync(sandboxRoot, { recursive: true, force: true });
-    mkdirSync(chapterhouseHome, { recursive: true });
-}
-test.beforeEach(async () => {
-    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
-    dbModule.closeDb();
-    resetSandbox();
-});
-test.after(async () => {
-    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
-    dbModule.closeDb();
-    rmSync(sandboxRoot, { recursive: true, force: true });
-});
-test("getDb creates memory tables and indexes", async () => {
-    const { dbModule } = await loadModules();
-    try {
-        const db = dbModule.getDb();
-        const tables = new Set(db.prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name LIKE 'mem_%'`).all()
-            .map((row) => row.name));
-        const indexes = new Set(db.prepare(`SELECT name FROM sqlite_master WHERE type = 'index' AND name LIKE 'mem_%'`).all()
-            .map((row) => row.name));
-        for (const name of [
-            "mem_scopes",
-            "mem_entities",
-            "mem_observations",
-            "mem_decisions",
-            "mem_inbox",
-        ]) {
-            assert.equal(tables.has(name), true, `expected memory table ${name}`);
-        }
-        for (const name of [
-            "mem_scopes_slug_idx",
-            "mem_entities_scope_kind_idx",
-            "mem_observations_scope_idx",
-            "mem_decisions_scope_idx",
-            "mem_inbox_status_idx",
-        ]) {
-            assert.equal(indexes.has(name), true, `expected memory index ${name}`);
-        }
-    }
-    finally {
-        dbModule.closeDb();
-    }
-});
-test("getDb seeds canonical memory scopes on first run", async () => {
-    const { dbModule } = await loadModules();
-    try {
-        const db = dbModule.getDb();
-        const rows = db.prepare(`
-      SELECT slug, title, description, keywords, active
-      FROM mem_scopes
-      ORDER BY slug
-    `).all();
-        assert.deepEqual(rows, [
-            {
-                slug: "chapterhouse",
-                title: "Chapterhouse",
-                description: "Chapterhouse codebase, conventions, decisions, gotchas",
-                keywords: JSON.stringify(["chapterhouse", "this repo", "this project", "the daemon"]),
-                active: 1,
-            },
-            {
-                slug: "global",
-                title: "Global",
-                description: "Cross-cutting facts that apply everywhere",
-                keywords: JSON.stringify(["everywhere", "general"]),
-                active: 1,
-            },
-        ]);
-    }
-    finally {
-        dbModule.closeDb();
-    }
-});
-test("memory schema initialization is idempotent", async () => {
-    const { dbModule } = await loadModules();
-    try {
-        dbModule.getDb();
-        dbModule.closeDb();
-        const reopened = await loadModules();
-        const db = reopened.dbModule.getDb();
-        const counts = db.prepare(`
-      SELECT slug, COUNT(*) AS count
-      FROM mem_scopes
-      GROUP BY slug
-      ORDER BY slug
-    `).all();
-        assert.deepEqual(counts, [
-            { slug: "chapterhouse", count: 1 },
-            { slug: "global", count: 1 },
-        ]);
-        reopened.dbModule.closeDb();
-    }
-    finally {
-        dbModule.closeDb();
-    }
-});
-test("scope CRUD creates, reads, lists, updates, deactivates, and preserves keywords", async () => {
-    const { dbModule, memoryModule } = await loadModules();
-    try {
-        const created = memoryModule.createScope({
-            slug: "docs-site",
-            title: "Docs Site",
-            description: "Documentation publishing and content workflows",
-            keywords: ["docs", "content", "publish"],
-        });
-        assert.equal(created.slug, "docs-site");
-        assert.equal(created.title, "Docs Site");
-        assert.equal(created.description, "Documentation publishing and content workflows");
-        assert.deepEqual(created.keywords, ["docs", "content", "publish"]);
-        assert.equal(created.active, true);
-        assert.deepEqual(memoryModule.getScope("docs-site"), created);
-        assert.deepEqual(memoryModule.getScope(created.id), created);
-        const listed = memoryModule.listScopes();
-        assert.equal(listed.some((scope) => scope.slug === "docs-site"), true);
-        await new Promise((resolve) => setTimeout(resolve, 1_100));
-        const updated = memoryModule.updateScope(created.id, {
-            title: "Docs Platform",
-            description: "Docs platform and release content",
-            keywords: ["docs", "release", "guides"],
-        });
-        assert.equal(updated.id, created.id);
-        assert.equal(updated.slug, "docs-site");
-        assert.equal(updated.title, "Docs Platform");
-        assert.equal(updated.description, "Docs platform and release content");
-        assert.deepEqual(updated.keywords, ["docs", "release", "guides"]);
-        assert.notEqual(updated.updatedAt, created.updatedAt);
-        const inactive = memoryModule.deactivateScope(created.id);
-        assert.equal(inactive.active, false);
-        assert.deepEqual(inactive.keywords, ["docs", "release", "guides"]);
-        assert.deepEqual(memoryModule.getScope(created.id), inactive);
-        const storedKeywords = dbModule.getDb()
-            .prepare(`SELECT keywords FROM mem_scopes WHERE id = ?`)
-            .get(created.id).keywords;
-        assert.deepEqual(JSON.parse(storedKeywords), ["docs", "release", "guides"]);
-    }
-    finally {
-        dbModule.closeDb();
-    }
-});
-test("createScope enforces unique slugs", async () => {
-    const { dbModule, memoryModule } = await loadModules();
-    try {
-        memoryModule.createScope({
-            slug: "shared",
-            title: "Shared",
-            description: "Shared scope",
-            keywords: ["shared"],
-        });
-        assert.throws(() => memoryModule.createScope({
-            slug: "shared",
-            title: "Shared Again",
-            description: "Duplicate scope",
-            keywords: ["duplicate"],
-        }), /UNIQUE|constraint/i);
-    }
-    finally {
-        dbModule.closeDb();
-    }
-});
-//# sourceMappingURL=scopes.test.js.map

package/dist/memory/tiering.js

@@ -1,223 +0,0 @@
-import { config } from "../config.js";
-import { getDb } from "../store/db.js";
-import { childLogger } from "../util/logger.js";
-const log = childLogger("memory.tiering");
-const TABLES = {
-    observation: "mem_observations",
-    decision: "mem_decisions",
-    entity: "mem_entities",
-    action_item: "mem_action_items",
-};
-function dbTable(table) {
-    return TABLES[table];
-}
-function passSummary(pass, examined = 0, modified = 0, errors = []) {
-    return { pass, examined, modified, errors };
-}
-function isRecent(value, days) {
-    if (!value) {
-        return false;
-    }
-    const parsed = new Date(value.includes("T") ? value : value.replace(" ", "T"));
-    if (Number.isNaN(parsed.getTime())) {
-        return false;
-    }
-    return parsed.getTime() >= Date.now() - days * 24 * 60 * 60 * 1000;
-}
-export function inferTierFromSignals(row) {
-    if (row.archived_at || row.superseded_by) {
-        return "cold";
-    }
-    if (row.tier === "glacier") {
-        return "cold";
-    }
-    if (row.confidence !== undefined && row.confidence !== null && row.confidence > 0.7) {
-        const timestamp = row.created_at ?? row.decided_at ?? row.updated_at;
-        if (isRecent(timestamp, 30)) {
-            return "hot";
-        }
-    }
-    return row.tier === "hot" || row.tier === "cold" ? row.tier : "warm";
-}
-function setTier(table, id, tier, reason, manual) {
-    const result = getDb().prepare(`
-    UPDATE ${dbTable(table)}
-    SET tier = ?, tier_reason = ?, tier_pinned_at = ${manual ? "CURRENT_TIMESTAMP" : "tier_pinned_at"}
-    WHERE id = ?
-  `).run(tier, reason, id);
-    if (result.changes === 0) {
-        throw new Error(`Unknown memory ${table} id '${id}'.`);
-    }
-    log.info({ table, id, tier, reason, manual }, "memory.tier.set");
-}
-export function promoteToHot(table, id, reason) {
-    setTier(table, id, "hot", reason, true);
-}
-export function demoteToWarm(table, id, reason) {
-    setTier(table, id, "warm", reason, true);
-}
-export function demoteToCold(table, id, reason) {
-    setTier(table, id, "cold", reason, true);
-}
-function updateTier(sql, params) {
-    return getDb().prepare(sql).run(...params).changes;
-}
-export function tieringPass(scopeId) {
-    if (!config.memoryTieringEnabled) {
-        return passSummary("tieringPass");
-    }
-    try {
-        const db = getDb();
-        const counts = db.prepare(`
-      SELECT
-        (SELECT COUNT(*) FROM mem_observations WHERE scope_id = ?) AS observations,
-        (SELECT COUNT(*) FROM mem_decisions WHERE scope_id = ?) AS decisions,
-        (SELECT COUNT(*) FROM mem_entities WHERE scope_id = ?) AS entities,
-        (SELECT COUNT(*) FROM mem_action_items WHERE scope_id = ?) AS action_items
-    `).get(scopeId, scopeId, scopeId, scopeId);
-        let modified = 0;
-        const tx = db.transaction(() => {
-            modified += updateTier(`
-        UPDATE mem_observations
-        SET tier = 'cold', tier_reason = 'archived or superseded'
-        WHERE scope_id = ?
-          AND tier != 'cold'
-          AND tier_pinned_at IS NULL
-          AND (archived_at IS NOT NULL OR superseded_by IS NOT NULL)
-      `, [scopeId]);
-            modified += updateTier(`
-        UPDATE mem_decisions
-        SET tier = 'cold', tier_reason = 'archived or superseded'
-        WHERE scope_id = ?
-          AND tier != 'cold'
-          AND tier_pinned_at IS NULL
-          AND (archived_at IS NOT NULL OR superseded_by IS NOT NULL)
-      `, [scopeId]);
-            modified += updateTier(`
-        UPDATE mem_observations
-        SET tier = 'hot', tier_reason = 'referenced by recent entity decision'
-        WHERE scope_id = ?
-          AND tier != 'hot'
-          AND tier_pinned_at IS NULL
-          AND archived_at IS NULL
-          AND superseded_by IS NULL
-          AND entity_id IS NOT NULL
-          AND EXISTS (
-            SELECT 1
-            FROM mem_decisions d
-            WHERE d.scope_id = mem_observations.scope_id
-              AND d.entity_id = mem_observations.entity_id
-              AND d.archived_at IS NULL
-              AND d.superseded_by IS NULL
-              AND datetime(d.decided_at) >= datetime('now', '-7 days')
-          )
-      `, [scopeId]);
-            modified += updateTier(`
-        UPDATE mem_decisions
-        SET tier = 'hot', tier_reason = 'recent decision restatement'
-        WHERE scope_id = ?
-          AND tier != 'hot'
-          AND tier_pinned_at IS NULL
-          AND archived_at IS NULL
-          AND (
-            datetime(decided_at) >= datetime('now', '-7 days')
-            OR EXISTS (
-              SELECT 1
-              FROM mem_decisions old
-              WHERE old.superseded_by = mem_decisions.id
-                AND datetime(mem_decisions.decided_at) >= datetime('now', '-7 days')
-            )
-          )
-      `, [scopeId]);
-            modified += updateTier(`
-        UPDATE mem_entities
-        SET tier = 'hot', tier_reason = 'referenced by three recent observations'
-        WHERE scope_id = ?
-          AND tier != 'hot'
-          AND tier_pinned_at IS NULL
-          AND (
-            SELECT COUNT(*)
-            FROM mem_observations o
-            WHERE o.entity_id = mem_entities.id
-              AND o.archived_at IS NULL
-              AND o.superseded_by IS NULL
-              AND datetime(o.created_at) >= datetime('now', '-7 days')
-          ) >= 3
-      `, [scopeId]);
-            modified += updateTier(`
-        UPDATE mem_observations
-        SET tier = 'warm', tier_reason = 'hot age threshold without recall'
-        WHERE scope_id = ?
-          AND tier = 'hot'
-          AND tier_pinned_at IS NULL
-          AND archived_at IS NULL
-          AND superseded_by IS NULL
-          AND last_recalled_at IS NULL
-          AND datetime(created_at) < datetime('now', ?)
-      `, [scopeId, `-${config.memoryHotAgeDays} days`]);
-            modified += updateTier(`
-        UPDATE mem_decisions
-        SET tier = 'warm', tier_reason = 'hot age threshold without recall'
-        WHERE scope_id = ?
-          AND tier = 'hot'
-          AND tier_pinned_at IS NULL
-          AND archived_at IS NULL
-          AND superseded_by IS NULL
-          AND last_recalled_at IS NULL
-          AND datetime(decided_at) < datetime('now', ?)
-      `, [scopeId, `-${config.memoryHotAgeDays} days`]);
-            modified += updateTier(`
-        UPDATE mem_action_items
-        SET tier = 'cold', tier_reason = 'resolved action item'
-        WHERE scope_id = ?
-          AND tier != 'cold'
-          AND tier_pinned_at IS NULL
-          AND status IN ('done', 'dropped')
-      `, [scopeId]);
-            modified += updateTier(`
-        UPDATE mem_action_items
-        SET tier = 'hot', tier_reason = 'open action item due soon'
-        WHERE scope_id = ?
-          AND tier != 'hot'
-          AND tier_pinned_at IS NULL
-          AND status = 'open'
-          AND due_at IS NOT NULL
-          AND datetime(due_at) <= datetime('now', '+7 days')
-      `, [scopeId]);
-            modified += updateTier(`
-        UPDATE mem_action_items
-        SET tier = 'warm', tier_reason = 'hot age threshold without recall'
-        WHERE scope_id = ?
-          AND tier = 'hot'
-          AND tier_pinned_at IS NULL
-          AND status = 'open'
-          AND last_recalled_at IS NULL
-          AND datetime(created_at) < datetime('now', ?)
-      `, [scopeId, `-${config.memoryHotAgeDays} days`]);
-            modified += updateTier(`
-        UPDATE mem_observations
-        SET tier = 'cold', tier_reason = 'stale low confidence'
-        WHERE scope_id = ?
-          AND tier = 'warm'
-          AND tier_pinned_at IS NULL
-          AND confidence < 0.3
-          AND datetime(created_at) < datetime('now', '-60 days')
-      `, [scopeId]);
-            modified += updateTier(`
-        UPDATE mem_entities
-        SET tier = 'cold', tier_reason = 'stale low confidence'
-        WHERE scope_id = ?
-          AND tier = 'warm'
-          AND tier_pinned_at IS NULL
-          AND confidence < 0.3
-          AND datetime(updated_at) < datetime('now', '-60 days')
-      `, [scopeId]);
-        });
-        tx();
-        return passSummary("tieringPass", counts.observations + counts.decisions + counts.entities + counts.action_items, modified);
-    }
-    catch (error) {
-        return passSummary("tieringPass", 0, 0, [error instanceof Error ? error.message : String(error)]);
-    }
-}
-//# sourceMappingURL=tiering.js.map