chapterhouse 0.13.1 → 0.14.0

package/dist/memory/tools/domains.test.js

@@ -0,0 +1,66 @@
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+import { gitAvailable, gitLog } from "../git.js";
+import { MemoryManager } from "../manager.js";
+import { createMemoryTools } from "./index.js";
+const sandbox = join(process.cwd(), ".test-work", `mem-tools-domains-${process.pid}`);
+function findTool(tools, name) {
+    const found = tools.find((t) => t.name === name);
+    assert.ok(found, `tool ${name} not found`);
+    return found;
+}
+async function call(tool, args) {
+    const result = await tool.handler(args, {
+        sessionId: "t",
+        toolCallId: "t",
+        toolName: tool.name,
+        arguments: args,
+    });
+    return String(result);
+}
+async function setup() {
+    const mgr = new MemoryManager(sandbox);
+    await mgr.ensureReady();
+    return { tools: createMemoryTools(mgr), mgr };
+}
+test.beforeEach(() => {
+    rmSync(sandbox, { recursive: true, force: true });
+    mkdirSync(sandbox, { recursive: true });
+});
+test.after(() => rmSync(sandbox, { recursive: true, force: true }));
+test("cog_domains returns the manifest", async () => {
+    if (!gitAvailable())
+        return;
+    const { tools } = await setup();
+    const out = await call(findTool(tools, "cog_domains"), {});
+    assert.ok(out.includes("id: personal"));
+    assert.ok(out.includes("id: cog-meta"));
+});
+test("cog_domain_create appends a domain, scaffolds it, and commits", async () => {
+    if (!gitAvailable())
+        return;
+    const { tools, mgr } = await setup();
+    const out = await call(findTool(tools, "cog_domain_create"), {
+        id: "acme",
+        path: "work/acme",
+        type: "work",
+        label: "Acme work",
+        triggers: ["acme"],
+    });
+    assert.match(out, /created domain "acme"/);
+    assert.ok(existsSync(join(mgr.paths.memoryRoot, "work/acme/hot-memory.md")));
+    assert.ok(existsSync(join(mgr.paths.skillsDomains, "acme", "SKILL.md")));
+    assert.ok((await gitLog(mgr.paths.memoryRoot, 50)).includes("feat: add domain acme"));
+    const manifest = await call(findTool(tools, "cog_domains"), {});
+    assert.ok(manifest.includes("id: acme"));
+});
+test("cog_domain_create rejects a duplicate id and an invalid type", async () => {
+    if (!gitAvailable())
+        return;
+    const { tools } = await setup();
+    assert.match(await call(findTool(tools, "cog_domain_create"), { id: "personal", path: "personal", type: "personal", label: "dup" }), /already exists/);
+    assert.match(await call(findTool(tools, "cog_domain_create"), { id: "x", path: "x", type: "bogus", label: "bad" }), /invalid type/);
+});
+//# sourceMappingURL=domains.test.js.map

package/dist/memory/tools/git.js

@@ -0,0 +1,52 @@
+// Git tool: cog_git — runs git operations on the memory repository.
+// Ported from chgo's tools_git.go.
+import { defineTool } from "@github/copilot-sdk";
+import { z } from "zod";
+import { gitCommitAll, gitDiff, gitLog, gitStatus } from "../git.js";
+import { withMemoryLock } from "./commit-wrapper.js";
+import { toolError } from "./shared.js";
+export function createGitTools(manager) {
+    const root = manager.paths.memoryRoot;
+    return [
+        defineTool("cog_git", {
+            description: "Run a git operation on the memory repository. op is one of: status, " +
+                "diff (optional ref and paths), log (optional limit), commit (requires message).",
+            parameters: z.object({
+                op: z.enum(["status", "diff", "log", "commit"]).describe("status | diff | log | commit"),
+                ref: z.string().optional().describe("Optional (diff): a git ref such as HEAD~1"),
+                paths: z.array(z.string()).optional().describe("Optional (diff): paths to scope the diff"),
+                limit: z.number().int().optional().describe("Optional (log): number of commits, default 15"),
+                message: z.string().optional().describe("Required (commit): the commit message"),
+            }),
+            handler: async (args) => {
+                try {
+                    switch (args.op) {
+                        case "status": {
+                            const status = await gitStatus(root);
+                            return status.trim() === "" ? "(clean)" : status;
+                        }
+                        case "diff": {
+                            const diff = await gitDiff(root, args.ref, args.paths);
+                            return diff.trim() === "" ? "(no diff)" : diff;
+                        }
+                        case "log":
+                            return await gitLog(root, args.limit ?? 15);
+                        case "commit": {
+                            if (!args.message)
+                                return "Error: commit requires a message";
+                            const message = args.message;
+                            await withMemoryLock(manager, () => gitCommitAll(root, message));
+                            return `committed: ${message}`;
+                        }
+                        default:
+                            return `Error: unknown op`;
+                    }
+                }
+                catch (err) {
+                    return toolError(err);
+                }
+            },
+        }),
+    ];
+}
+//# sourceMappingURL=git.js.map

package/dist/memory/tools/index.js

@@ -0,0 +1,25 @@
+// Assembles the complete cog_* tool surface. Every name carries the cog_
+// prefix so it cannot collide with an SDK built-in. Ported from chgo's tools.go.
+import { createReadTools } from "./read.js";
+import { createWriteTools } from "./write.js";
+import { createSearchTools } from "./search.js";
+import { createGitTools } from "./git.js";
+import { createDomainTools } from "./domains.js";
+import { createSessionsTool } from "./sessions.js";
+/**
+ * Returns the 14 memory tools. When memory is unavailable (git missing, or not
+ * scaffolded) it returns an empty list so the daemon and agents keep working.
+ */
+export function createMemoryTools(manager) {
+    if (!manager || !manager.isReady())
+        return [];
+    return [
+        ...createReadTools(manager),
+        ...createWriteTools(manager),
+        ...createSearchTools(manager),
+        ...createGitTools(manager),
+        ...createDomainTools(manager),
+        createSessionsTool(manager),
+    ];
+}
+//# sourceMappingURL=index.js.map

package/dist/memory/tools/read.js

@@ -0,0 +1,101 @@
+// Read tools: cog_read, cog_l0_scan, cog_l1_outline, cog_tree.
+// Ported from chgo's tools_read.go.
+import { defineTool } from "@github/copilot-sdk";
+import { z } from "zod";
+import { readFileSync } from "fs";
+import { resolveMemoryPath } from "../path-guard.js";
+import { walkMemoryMarkdown } from "../walk.js";
+import { extractL0, extractLines, extractSection } from "../markdown.js";
+import { toolError } from "./shared.js";
+export function createReadTools(manager) {
+    const root = manager.paths.memoryRoot;
+    return [
+        defineTool("cog_read", {
+            description: "Read a memory file. Optionally extract one section by heading text, or a 1-based " +
+                "line range. Paths are relative to the memory root; a leading 'memory/' is accepted.",
+            parameters: z.object({
+                path: z.string().describe("File path, e.g. personal/hot-memory.md"),
+                section: z.string().optional().describe("Optional: heading text to extract, e.g. 'Current State'"),
+                start: z.number().int().optional().describe("Optional: 1-based start line"),
+                end: z.number().int().optional().describe("Optional: 1-based end line, inclusive"),
+            }),
+            handler: async (args) => {
+                try {
+                    const abs = resolveMemoryPath(root, args.path);
+                    const content = readFileSync(abs, "utf8");
+                    if (args.section)
+                        return extractSection(content, args.section);
+                    const start = args.start ?? 0;
+                    const end = args.end ?? 0;
+                    if (start > 0 || end > 0)
+                        return extractLines(content, start, end);
+                    return content;
+                }
+                catch (err) {
+                    return toolError(err);
+                }
+            },
+        }),
+        defineTool("cog_l0_scan", {
+            description: "Scan one-line <!-- L0: --> summaries across the memory tree (the L0 retrieval tier). " +
+                "Optionally scope to a domain path.",
+            parameters: z.object({
+                domain: z.string().optional().describe("Optional: a domain path to scope the scan, e.g. personal"),
+            }),
+            handler: async (args) => {
+                try {
+                    const lines = [];
+                    walkMemoryMarkdown(root, args.domain, (rel, abs) => {
+                        const l0 = extractL0(readFileSync(abs, "utf8"));
+                        lines.push(`${rel} — ${l0 || "(no L0)"}`);
+                    });
+                    return lines.length === 0 ? "(no memory files)" : lines.join("\n") + "\n";
+                }
+                catch (err) {
+                    return toolError(err);
+                }
+            },
+        }),
+        defineTool("cog_l1_outline", {
+            description: "List a memory file's section headings with line numbers (the L1 retrieval tier).",
+            parameters: z.object({
+                path: z.string().describe("File path"),
+            }),
+            handler: async (args) => {
+                try {
+                    const abs = resolveMemoryPath(root, args.path);
+                    const data = readFileSync(abs, "utf8");
+                    const out = [];
+                    data.split("\n").forEach((line, i) => {
+                        const t = line.trim();
+                        if (t.startsWith("#"))
+                            out.push(`${i + 1}: ${t}`);
+                    });
+                    return out.length === 0 ? "(no headings)" : out.join("\n") + "\n";
+                }
+                catch (err) {
+                    return toolError(err);
+                }
+            },
+        }),
+        defineTool("cog_tree", {
+            description: "List memory files. Optionally scope to a domain path.",
+            parameters: z.object({
+                domain: z.string().optional().describe("Optional: a domain path, e.g. work/acme"),
+            }),
+            handler: async (args) => {
+                try {
+                    const files = [];
+                    walkMemoryMarkdown(root, args.domain, (rel) => {
+                        files.push(rel);
+                    });
+                    return files.length === 0 ? "(no memory files)" : files.join("\n") + "\n";
+                }
+                catch (err) {
+                    return toolError(err);
+                }
+            },
+        }),
+    ];
+}
+//# sourceMappingURL=read.js.map

package/dist/memory/tools/read.test.js

@@ -0,0 +1,69 @@
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+import { gitAvailable } from "../git.js";
+import { MemoryManager } from "../manager.js";
+import { createMemoryTools } from "./index.js";
+const sandbox = join(process.cwd(), ".test-work", `mem-tools-read-${process.pid}`);
+function findTool(tools, name) {
+    const found = tools.find((t) => t.name === name);
+    assert.ok(found, `tool ${name} not found`);
+    return found;
+}
+async function call(tool, args) {
+    const result = await tool.handler(args, {
+        sessionId: "t",
+        toolCallId: "t",
+        toolName: tool.name,
+        arguments: args,
+    });
+    return String(result);
+}
+async function setup() {
+    const mgr = new MemoryManager(sandbox);
+    await mgr.ensureReady();
+    const tools = createMemoryTools(mgr);
+    await call(findTool(tools, "cog_write"), {
+        path: "personal/notes.md",
+        content: "<!-- L0: my notes -->\n# Notes\n## Current State\nstate body\n## Next\nnext body",
+    });
+    return tools;
+}
+test.beforeEach(() => {
+    rmSync(sandbox, { recursive: true, force: true });
+    mkdirSync(sandbox, { recursive: true });
+});
+test.after(() => rmSync(sandbox, { recursive: true, force: true }));
+test("cog_read returns full content, a section, and a line range", async () => {
+    if (!gitAvailable())
+        return;
+    const tools = await setup();
+    const read = findTool(tools, "cog_read");
+    assert.match(await call(read, { path: "personal/notes.md" }), /state body[\s\S]*next body/);
+    assert.equal(await call(read, { path: "personal/notes.md", section: "current state" }), "## Current State\nstate body");
+    assert.equal(await call(read, { path: "personal/notes.md", start: 1, end: 2 }), "<!-- L0: my notes -->\n# Notes");
+});
+test("cog_l0_scan reports L0 summaries", async () => {
+    if (!gitAvailable())
+        return;
+    const tools = await setup();
+    const out = await call(findTool(tools, "cog_l0_scan"), { domain: "personal" });
+    assert.ok(out.includes("personal/notes.md — my notes"));
+});
+test("cog_l1_outline lists headings with line numbers", async () => {
+    if (!gitAvailable())
+        return;
+    const tools = await setup();
+    const out = await call(findTool(tools, "cog_l1_outline"), { path: "personal/notes.md" });
+    assert.ok(out.includes("# Notes"));
+    assert.ok(out.includes("## Current State"));
+});
+test("cog_tree lists memory files", async () => {
+    if (!gitAvailable())
+        return;
+    const tools = await setup();
+    const out = await call(findTool(tools, "cog_tree"), { domain: "personal" });
+    assert.ok(out.includes("personal/notes.md"));
+});
+//# sourceMappingURL=read.test.js.map

package/dist/memory/tools/search.js

@@ -0,0 +1,103 @@
+// Search tools: cog_search, cog_stats. Ported from chgo's tools_search.go.
+import { defineTool } from "@github/copilot-sdk";
+import { z } from "zod";
+import { readFileSync, statSync } from "fs";
+import { resolveMemoryPath } from "../path-guard.js";
+import { walkMemoryMarkdown } from "../walk.js";
+import { toolError } from "./shared.js";
+const SEARCH_MATCH_LIMIT = 200;
+export function createSearchTools(manager) {
+    const root = manager.paths.memoryRoot;
+    return [
+        defineTool("cog_search", {
+            description: "Search memory files for a regular expression. Returns matching lines as " +
+                "path:line: text. Optionally scope to a domain path.",
+            parameters: z.object({
+                pattern: z.string().describe("A regular expression"),
+                domain: z.string().optional().describe("Optional: a domain path to scope the search"),
+            }),
+            handler: async (args) => {
+                try {
+                    let re;
+                    try {
+                        re = new RegExp(args.pattern);
+                    }
+                    catch (err) {
+                        return `Error: invalid pattern: ${err.message}`;
+                    }
+                    const out = [];
+                    let matches = 0;
+                    walkMemoryMarkdown(root, args.domain, (rel, abs) => {
+                        if (matches >= SEARCH_MATCH_LIMIT)
+                            return;
+                        const lines = readFileSync(abs, "utf8").split("\n");
+                        for (let i = 0; i < lines.length; i++) {
+                            if (matches >= SEARCH_MATCH_LIMIT)
+                                break;
+                            if (re.test(lines[i])) {
+                                out.push(`${rel}:${i + 1}: ${lines[i].trim()}`);
+                                matches++;
+                            }
+                        }
+                    });
+                    if (matches === 0)
+                        return "(no matches)";
+                    if (matches >= SEARCH_MATCH_LIMIT) {
+                        out.push(`(truncated at ${SEARCH_MATCH_LIMIT} matches)`);
+                    }
+                    return out.join("\n") + "\n";
+                }
+                catch (err) {
+                    return toolError(err);
+                }
+            },
+        }),
+        defineTool("cog_stats", {
+            description: "Report line count, byte size, list-entry count, and completed-entry count " +
+                "for memory files — used for archival and cap checks.",
+            parameters: z.object({
+                paths: z.array(z.string()).describe("Memory file paths to measure"),
+            }),
+            handler: async (args) => {
+                try {
+                    if (args.paths.length === 0)
+                        return "Error: paths is required";
+                    const out = [];
+                    for (const rel of args.paths) {
+                        let abs;
+                        try {
+                            abs = resolveMemoryPath(root, rel);
+                        }
+                        catch (err) {
+                            return toolError(err);
+                        }
+                        let data;
+                        try {
+                            data = readFileSync(abs, "utf8");
+                        }
+                        catch (err) {
+                            out.push(`${rel} — error: ${err.message}`);
+                            continue;
+                        }
+                        const lines = data.split("\n");
+                        let entries = 0;
+                        let done = 0;
+                        for (const line of lines) {
+                            if (line.startsWith("- "))
+                                entries++;
+                            if (line.startsWith("- [x]") || line.startsWith("- [X]"))
+                                done++;
+                        }
+                        const bytes = statSync(abs).size;
+                        out.push(`${rel} — lines: ${lines.length}, bytes: ${bytes}, entries: ${entries}, done: ${done}`);
+                    }
+                    return out.join("\n") + "\n";
+                }
+                catch (err) {
+                    return toolError(err);
+                }
+            },
+        }),
+    ];
+}
+//# sourceMappingURL=search.js.map

package/dist/memory/tools/search.test.js

@@ -0,0 +1,63 @@
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+import { gitAvailable } from "../git.js";
+import { MemoryManager } from "../manager.js";
+import { createMemoryTools } from "./index.js";
+const sandbox = join(process.cwd(), ".test-work", `mem-tools-search-${process.pid}`);
+function findTool(tools, name) {
+    const found = tools.find((t) => t.name === name);
+    assert.ok(found, `tool ${name} not found`);
+    return found;
+}
+async function call(tool, args) {
+    const result = await tool.handler(args, {
+        sessionId: "t",
+        toolCallId: "t",
+        toolName: tool.name,
+        arguments: args,
+    });
+    return String(result);
+}
+async function setup() {
+    const mgr = new MemoryManager(sandbox);
+    await mgr.ensureReady();
+    const tools = createMemoryTools(mgr);
+    await call(findTool(tools, "cog_write"), {
+        path: "personal/observations.md",
+        content: "<!-- L0: obs -->\n- [x] shipped the release\n- [ ] write the changelog\n- ran the tests",
+    });
+    return tools;
+}
+test.beforeEach(() => {
+    rmSync(sandbox, { recursive: true, force: true });
+    mkdirSync(sandbox, { recursive: true });
+});
+test.after(() => rmSync(sandbox, { recursive: true, force: true }));
+test("cog_search returns matching lines and reports no matches", async () => {
+    if (!gitAvailable())
+        return;
+    const tools = await setup();
+    const search = findTool(tools, "cog_search");
+    const hit = await call(search, { pattern: "changelog", domain: "personal" });
+    assert.ok(hit.includes("personal/observations.md:"));
+    assert.ok(hit.includes("write the changelog"));
+    assert.equal(await call(search, { pattern: "no-such-text", domain: "personal" }), "(no matches)");
+});
+test("cog_search reports an invalid pattern", async () => {
+    if (!gitAvailable())
+        return;
+    const tools = await setup();
+    assert.match(await call(findTool(tools, "cog_search"), { pattern: "[unclosed" }), /invalid pattern/);
+});
+test("cog_stats counts lines, entries, and completed entries", async () => {
+    if (!gitAvailable())
+        return;
+    const tools = await setup();
+    const out = await call(findTool(tools, "cog_stats"), { paths: ["personal/observations.md"] });
+    assert.ok(out.includes("personal/observations.md"));
+    assert.ok(out.includes("entries: 3"));
+    assert.ok(out.includes("done: 1"));
+});
+//# sourceMappingURL=search.test.js.map

package/dist/memory/tools/sessions.js

@@ -0,0 +1,45 @@
+// Sessions tool: cog_sessions — returns past conversation history for the
+// reflect/history skills. Ported from chgo's history.go toolSessions.
+import { defineTool } from "@github/copilot-sdk";
+import { z } from "zod";
+import { toolError } from "./shared.js";
+export function createSessionsTool(manager) {
+    return defineTool("cog_sessions", {
+        description: "Return past conversation history (the Chapterhouse equivalent of session " +
+            "transcripts). With no 'since', returns the most recent sessions. Note: " +
+            "history is bounded to recent conversations — advance the reflect cursor each run.",
+        parameters: z.object({
+            since: z.string().optional().describe("Optional: ISO-8601 timestamp; only turns after it are returned"),
+            limit: z.number().int().optional().describe("Optional: maximum number of sessions"),
+        }),
+        handler: async (args) => {
+            try {
+                const source = manager.getSessionSource();
+                let since;
+                const raw = args.since?.trim();
+                if (raw && raw !== "never")
+                    since = raw;
+                let limit = args.limit ?? 0;
+                if (!since && limit === 0) {
+                    limit = 3; // cog: when the cursor is "never", read the recent 3 sessions
+                }
+                const sessions = await source.sessionHistory(since, limit);
+                if (sessions.length === 0)
+                    return "(no sessions)";
+                let out = "";
+                for (const session of sessions) {
+                    out += `Session ${session.conversationId} (${session.agentSlug}, started ${session.startedAt}):\n`;
+                    for (const turn of session.turns) {
+                        out += `  [${turn.role}] ${turn.text}\n`;
+                    }
+                    out += "\n";
+                }
+                return out;
+            }
+            catch (err) {
+                return toolError(err);
+            }
+        },
+    });
+}
+//# sourceMappingURL=sessions.js.map

package/dist/memory/tools/sessions.test.js

@@ -0,0 +1,74 @@
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+const sandbox = join(process.cwd(), ".test-work", `mem-tools-sessions-${process.pid}`);
+process.env.CHAPTERHOUSE_HOME = sandbox;
+import { closeDb, getDb } from "../../store/connection.js";
+import { getConversationSessions, logConversation } from "../../store/repositories/sessions.js";
+import { gitAvailable } from "../git.js";
+import { MemoryManager } from "../manager.js";
+import { createMemoryTools } from "./index.js";
+function findTool(tools, name) {
+    const found = tools.find((t) => t.name === name);
+    assert.ok(found, `tool ${name} not found`);
+    return found;
+}
+async function call(tool, args) {
+    const result = await tool.handler(args, {
+        sessionId: "t",
+        toolCallId: "t",
+        toolName: tool.name,
+        arguments: args,
+    });
+    return String(result);
+}
+function seedConversations() {
+    getDb();
+    logConversation("user", "hello there", "web", "session-one");
+    logConversation("assistant", "hi back", "web", "session-one", { agentSlug: "chapterhouse" });
+    logConversation("user", "a question", "web", "session-two");
+    logConversation("agent_completion", "the answer", "web", "session-two", { agentSlug: "coder" });
+    logConversation("system", "ignored noise", "web", "session-two");
+}
+test.beforeEach(() => {
+    closeDb();
+    rmSync(sandbox, { recursive: true, force: true });
+    mkdirSync(sandbox, { recursive: true });
+});
+test.after(() => {
+    closeDb();
+    rmSync(sandbox, { recursive: true, force: true });
+});
+test("getConversationSessions groups turns and maps agent_completion to assistant", () => {
+    seedConversations();
+    const sessions = getConversationSessions();
+    assert.equal(sessions.length, 2);
+    const one = sessions.find((s) => s.sessionKey === "session-one");
+    const two = sessions.find((s) => s.sessionKey === "session-two");
+    assert.ok(one && two);
+    assert.deepEqual(one.turns.map((t) => t.role), ["user", "assistant"]);
+    assert.deepEqual(two.turns.map((t) => [t.role, t.content]), [
+        ["user", "a question"],
+        ["assistant", "the answer"], // agent_completion mapped, system row dropped
+    ]);
+});
+test("getConversationSessions honors the since filter and limit", () => {
+    seedConversations();
+    assert.equal(getConversationSessions("2999-01-01T00:00:00Z").length, 0);
+    assert.equal(getConversationSessions("2000-01-01T00:00:00Z").length, 2);
+    assert.equal(getConversationSessions(undefined, 1).length, 1);
+});
+test("cog_sessions formats recent conversation history", async () => {
+    if (!gitAvailable())
+        return;
+    seedConversations();
+    const mgr = new MemoryManager(sandbox);
+    await mgr.ensureReady();
+    const tools = createMemoryTools(mgr);
+    const out = await call(findTool(tools, "cog_sessions"), {});
+    assert.ok(out.includes("Session session-one"));
+    assert.ok(out.includes("[user] hello there"));
+    assert.ok(out.includes("[assistant] the answer"));
+});
+//# sourceMappingURL=sessions.test.js.map

package/dist/memory/tools/shared.js

@@ -0,0 +1,7 @@
+// Shared helpers for the memory tools.
+/** Formats an error as a readable, model-facing string. */
+export function toolError(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return `Error: ${message}`;
+}
+//# sourceMappingURL=shared.js.map