chapterhouse 0.3.15 → 0.3.16

package/dist/wiki/log-manager.js

@@ -1,20 +1,63 @@
 // ---------------------------------------------------------------------------
-// Wiki log.md manager — append-only chronological operation log
+// Wiki action-log manager — append-only chronological operation log
 // ---------------------------------------------------------------------------
-import { appendFileSync } from "fs";
+import { appendFileSync, existsSync, readFileSync, renameSync } from "fs";
 import { join } from "path";
-import { WIKI_DIR } from "../paths.js";
-import { ensureWikiStructure } from "./fs.js";
-const LOG_PATH = join(WIKI_DIR, "log.md");
+import { WIKI_PAGES_DIR } from "../paths.js";
+import { ensureWikiStructure, writeFileAtomic } from "./fs.js";
+export const ACTION_LOG_PATH = "pages/_meta/log.md";
+const LOG_PATH = join(WIKI_PAGES_DIR, "_meta", "log.md");
+const MAX_LOG_ENTRIES = 500;
+const LOG_ENTRY_RE = /^## \[/gm;
+const INITIAL_LOG = `# Wiki Action Log
+
+_Append-only record of wiki operations._
+
+`;
 /**
- * Append a timestamped entry to log.md.
- * Format: `## [YYYY-MM-DD HH:MM] type | description`
+ * Append a timestamped entry to pages/_meta/log.md.
+ * Format: `## [YYYY-MM-DD HH:MM] action | subject | agent`
  */
-export function appendLog(type, description) {
+export function appendLog(type, subject, agent = resolveAgentName()) {
     ensureWikiStructure();
+    rotateLogIfNeeded();
     const now = new Date();
     const ts = now.toISOString().slice(0, 16).replace("T", " ");
-    const entry = `## [${ts}] ${type} | ${description}\n\n`;
+    const entry = `## [${ts}] ${type} | ${subject} | ${agent}\n\n`;
     appendFileSync(LOG_PATH, entry, "utf-8");
 }
+function rotateLogIfNeeded() {
+    const currentLog = readFileSync(LOG_PATH, "utf-8");
+    const entryCount = (currentLog.match(LOG_ENTRY_RE) ?? []).length;
+    if (entryCount < MAX_LOG_ENTRIES) {
+        return;
+    }
+    const archivePath = join(WIKI_PAGES_DIR, "_meta", `log-${new Date().getFullYear()}.md`);
+    if (!existsSync(archivePath)) {
+        renameSync(LOG_PATH, archivePath);
+    }
+    else {
+        const archivedEntries = extractEntries(currentLog);
+        if (archivedEntries.length > 0) {
+            const separator = readFileSync(archivePath, "utf-8").endsWith("\n\n") ? "" : "\n\n";
+            appendFileSync(archivePath, `${separator}${archivedEntries.join("\n\n")}\n\n`, "utf-8");
+        }
+    }
+    writeFileAtomic(LOG_PATH, INITIAL_LOG);
+}
+function extractEntries(content) {
+    return content
+        .split(/\n{2,}/)
+        .map((chunk) => chunk.trim())
+        .filter((chunk) => chunk.startsWith("## ["));
+}
+function resolveAgentName() {
+    const candidates = [
+        process.env.CHAPTERHOUSE_SESSION_AGENT_NAME,
+        process.env.CHAPTERHOUSE_AGENT_NAME,
+        process.env.COPILOT_AGENT_NAME,
+        process.env.AGENT_NAME,
+    ];
+    return candidates.find((candidate) => candidate && candidate.trim().length > 0)?.trim() ?? "unknown";
+}
 //# sourceMappingURL=log-manager.js.map

package/dist/wiki/log-manager.test.js

@@ -0,0 +1,47 @@
+import assert from "node:assert/strict";
+import { existsSync, 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", `wiki-log-${process.pid}`);
+const wikiDir = join(sandboxRoot, ".chapterhouse", "wiki");
+process.env.CHAPTERHOUSE_HOME = sandboxRoot;
+process.env.CHAPTERHOUSE_AGENT_NAME = "wiki-test-agent";
+async function loadModules() {
+    const nonce = `${Date.now()}-${Math.random()}`;
+    const logManager = await import(new URL(`./log-manager.js?case=${nonce}`, import.meta.url).href);
+    const wikiFs = await import(new URL(`./fs.js?case=${nonce}`, import.meta.url).href);
+    return { logManager, wikiFs };
+}
+function resetSandbox() {
+    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
+    rmSync(sandboxRoot, { recursive: true, force: true });
+}
+test.beforeEach(() => {
+    resetSandbox();
+});
+test.after(() => {
+    rmSync(sandboxRoot, { recursive: true, force: true });
+});
+test("appendLog writes action entries to pages/_meta/log.md with the resolved agent name", async () => {
+    const { logManager, wikiFs } = await loadModules();
+    wikiFs.ensureWikiStructure();
+    logManager.appendLog("update", "wiki_update: Chapterhouse (pages/shared/chapterhouse.md)");
+    assert.equal(existsSync(join(wikiDir, "pages", "_meta", "log.md")), true);
+    assert.match(wikiFs.readLogFile(), /^## \[\d{4}-\d{2}-\d{2} \d{2}:\d{2}\] update \| wiki_update: Chapterhouse \(pages\/shared\/chapterhouse\.md\) \| wiki-test-agent/m);
+});
+test("appendLog rotates the active log after 500 entries and keeps appending to a fresh log", async () => {
+    const { logManager, wikiFs } = await loadModules();
+    wikiFs.ensureWikiStructure();
+    wikiFs.writeLogFile("# Wiki Action Log\n\n" +
+        Array.from({ length: 500 }, (_, index) => `## [2026-01-01 00:00] update | historical entry ${index + 1} | wiki-test-agent\n\n`).join(""));
+    logManager.appendLog("update", "fresh entry after rotation");
+    const archiveYear = String(new Date().getFullYear());
+    const activeLog = wikiFs.readLogFile();
+    const archivedLog = wikiFs.readPage(`pages/_meta/log-${archiveYear}.md`);
+    assert.ok(archivedLog);
+    assert.match(archivedLog, /historical entry 1/);
+    assert.doesNotMatch(activeLog, /historical entry 1/);
+    assert.match(activeLog, /fresh entry after rotation/);
+});
+//# sourceMappingURL=log-manager.test.js.map

package/dist/wiki/taxonomy.js

@@ -0,0 +1,73 @@
+import { readPage } from "./fs.js";
+const ENGINEERING_TAGS = [
+    "engineering",
+    "architecture",
+    "release",
+    "runbook",
+    "incident",
+    "orchestration",
+];
+const PEOPLE_TAGS = [
+    "people",
+    "person",
+    "org",
+    "team",
+    "tool",
+];
+const PROCESS_TAGS = [
+    "process",
+    "project",
+    "topic",
+    "area",
+    "decision",
+    "preference",
+    "fact",
+    "routine",
+    "research",
+];
+const META_TAGS = [
+    "meta",
+    "index",
+    "source",
+    "taxonomy",
+    "autostub",
+];
+export const DEFAULT_TAGS = [
+    ...ENGINEERING_TAGS,
+    ...PEOPLE_TAGS,
+    ...PROCESS_TAGS,
+    ...META_TAGS,
+];
+export const TAXONOMY_PATH = "pages/_meta/taxonomy.md";
+export function parseTaxonomyTags(content) {
+    const tags = new Set();
+    let seenHeading = false;
+    for (const rawLine of content.split("\n")) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        if (/^##\s+.+/.test(line)) {
+            seenHeading = true;
+            continue;
+        }
+        const bulletMatch = line.match(/^-\s+([a-z0-9][a-z0-9-]*)$/i);
+        if (bulletMatch && seenHeading) {
+            tags.add(bulletMatch[1].toLowerCase());
+            continue;
+        }
+        throw new Error(`Invalid wiki taxonomy at ${TAXONOMY_PATH}: expected '## Group' headings with '- tag' bullets.`);
+    }
+    return [...tags];
+}
+export function loadTaxonomy() {
+    const tags = new Set(DEFAULT_TAGS);
+    const override = readPage(TAXONOMY_PATH);
+    if (!override) {
+        return [...tags].sort();
+    }
+    for (const tag of parseTaxonomyTags(override)) {
+        tags.add(tag);
+    }
+    return [...tags].sort();
+}
+//# sourceMappingURL=taxonomy.js.map

package/dist/wiki/taxonomy.test.js

@@ -0,0 +1,70 @@
+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", `wiki-taxonomy-${process.pid}`);
+process.env.CHAPTERHOUSE_HOME = sandboxRoot;
+async function loadModules() {
+    const nonce = `${Date.now()}-${Math.random()}`;
+    const taxonomy = await import(new URL(`./taxonomy.js?case=${nonce}`, import.meta.url).href);
+    const wikiFs = await import(new URL(`./fs.js?case=${nonce}`, import.meta.url).href);
+    return { taxonomy, wikiFs };
+}
+function resetSandbox() {
+    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
+    rmSync(sandboxRoot, { recursive: true, force: true });
+}
+test.beforeEach(() => {
+    resetSandbox();
+});
+test.after(() => {
+    rmSync(sandboxRoot, { recursive: true, force: true });
+});
+test("loadTaxonomy returns the default tags when no wiki taxonomy file exists", async () => {
+    const { taxonomy } = await loadModules();
+    const merged = taxonomy.loadTaxonomy();
+    assert.deepEqual(merged, [...taxonomy.DEFAULT_TAGS].sort());
+});
+test("loadTaxonomy merges pages/_meta/taxonomy.md entries with the defaults", async () => {
+    const { taxonomy, wikiFs } = await loadModules();
+    wikiFs.writePage("pages/_meta/taxonomy.md", `## Engineering
+- orchestration
+- release
+
+## Custom Group
+- teammate
+`);
+    const merged = taxonomy.loadTaxonomy();
+    assert.equal(merged.includes("orchestration"), true);
+    assert.equal(merged.includes("release"), true);
+    assert.equal(merged.includes("teammate"), true);
+    assert.equal(merged.includes("engineering"), true);
+});
+test("loadTaxonomy deduplicates repeated tags across defaults and overrides", async () => {
+    const { taxonomy, wikiFs } = await loadModules();
+    wikiFs.writePage("pages/_meta/taxonomy.md", `## Engineering
+- engineering
+- release
+- release
+`);
+    const merged = taxonomy.loadTaxonomy();
+    assert.equal(merged.filter((tag) => tag === "engineering").length, 1);
+    assert.equal(merged.filter((tag) => tag === "release").length, 1);
+});
+test("loadTaxonomy accepts arbitrary heading labels as grouping metadata", async () => {
+    const { taxonomy, wikiFs } = await loadModules();
+    wikiFs.writePage("pages/_meta/taxonomy.md", `## Totally New Bucket
+- field-note
+`);
+    const merged = taxonomy.loadTaxonomy();
+    assert.equal(merged.includes("field-note"), true);
+});
+test("loadTaxonomy rejects malformed taxonomy markdown clearly", async () => {
+    const { taxonomy, wikiFs } = await loadModules();
+    wikiFs.writePage("pages/_meta/taxonomy.md", `## Engineering
+not-a-bullet
+`);
+    assert.throws(() => taxonomy.loadTaxonomy(), /Invalid wiki taxonomy/i);
+});
+//# sourceMappingURL=taxonomy.test.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chapterhouse",
-  "version": "0.3.15",
+  "version": "0.3.16",
   "description": "Chapterhouse — a team-level AI assistant for engineering teams, built on the GitHub Copilot SDK. Web UI only.",
   "bin": {
     "chapterhouse": "dist/cli.js"