chapterhouse 0.1.1

package/dist/wiki/seed-team-wiki.js

@@ -0,0 +1,296 @@
+import { fileURLToPath } from "node:url";
+import { resolve } from "node:path";
+import { ensureWikiStructure, readPage, writePage } from "./fs.js";
+import { addToIndex, buildIndexEntryForPage } from "./index-manager.js";
+import { generateKPIPage, generateOKRQuarterPage, generateTeamIndexPage, } from "./templates/okr.js";
+const SAMPLE_OBJECTIVES = [
+    {
+        id: "O1",
+        title: "Increase Azure platform deployment reliability across regulated regions",
+        owner: "Ava Wilson",
+        keyResults: [
+            {
+                id: "O1-KR1",
+                title: "Lift first-pass success for regional rollout pipelines from 72 to 95 percent",
+                owner: "Noah Patel",
+                targetValue: 95,
+                currentValue: 72,
+                unit: "%",
+                dueDate: "2026-06-30",
+            },
+            {
+                id: "O1-KR2",
+                title: "Cut mean time to restore failed environment promotions from 180 to 45 minutes",
+                owner: "Maya Chen",
+                targetValue: 45,
+                currentValue: 180,
+                unit: "minutes",
+                dueDate: "2026-06-15",
+            },
+            {
+                id: "O1-KR3",
+                title: "Automate compliance evidence capture for 100 percent of production releases",
+                owner: "Jordan Alvarez",
+                targetValue: 100,
+                currentValue: 20,
+                unit: "%",
+                dueDate: "2026-06-30",
+            },
+        ],
+    },
+    {
+        id: "O2",
+        title: "Improve Azure service onboarding velocity for internal product teams",
+        owner: "Lena Brooks",
+        keyResults: [
+            {
+                id: "O2-KR1",
+                title: "Reduce median landing zone provisioning time from 14 days to 5 days",
+                owner: "Priya Raman",
+                targetValue: 5,
+                currentValue: 14,
+                unit: "days",
+                dueDate: "2026-06-30",
+            },
+            {
+                id: "O2-KR2",
+                title: "Publish reusable Terraform blueprints covering 8 common Azure workloads",
+                owner: "Diego Martinez",
+                targetValue: 8,
+                currentValue: 2,
+                unit: "blueprints",
+                dueDate: "2026-06-20",
+            },
+            {
+                id: "O2-KR3",
+                title: "Raise onboarding satisfaction from 3.6 to 4.5 out of 5 in quarterly surveys",
+                owner: "Sofia Kim",
+                targetValue: 4.5,
+                currentValue: 3.6,
+                unit: "score",
+                dueDate: "2026-06-30",
+            },
+        ],
+    },
+];
+const SAMPLE_KPIS = [
+    {
+        id: "kpi-release-cadence",
+        name: "Production release cadence",
+        owner: "Ava Wilson",
+        target: 12,
+        current: 9,
+        unit: "releases",
+        frequency: "monthly",
+    },
+    {
+        id: "kpi-change-failure-rate",
+        name: "Change failure rate",
+        owner: "Noah Patel",
+        target: 5,
+        current: 8,
+        unit: "%",
+        frequency: "weekly",
+    },
+    {
+        id: "kpi-sev1-sev2-incidents",
+        name: "Sev1/Sev2 incidents",
+        owner: "Maya Chen",
+        target: 2,
+        current: 4,
+        unit: "count",
+        frequency: "monthly",
+    },
+    {
+        id: "kpi-infra-cost-variance",
+        name: "Azure spend variance to forecast",
+        owner: "Jordan Alvarez",
+        target: 3,
+        current: 6,
+        unit: "%",
+        frequency: "monthly",
+    },
+    {
+        id: "kpi-service-onboarding-time",
+        name: "Median service onboarding time",
+        owner: "Lena Brooks",
+        target: 5,
+        current: 11,
+        unit: "days",
+        frequency: "quarterly",
+    },
+];
+const PLACEHOLDER_MEMBERS = [
+    {
+        name: "TBD Engineer 1",
+        email: "engineer1@chapterhouse.example",
+        role: "team-lead",
+        entraObjectId: "00000000-0000-0000-0000-000000000001",
+        okrOwnership: ["O1-KR1", "O2-KR1"],
+    },
+    {
+        name: "TBD Engineer 2",
+        email: "engineer2@chapterhouse.example",
+        role: "engineer",
+        entraObjectId: "00000000-0000-0000-0000-000000000002",
+        okrOwnership: ["O1-KR2"],
+    },
+    {
+        name: "TBD Engineer 3",
+        email: "engineer3@chapterhouse.example",
+        role: "engineer",
+        entraObjectId: "00000000-0000-0000-0000-000000000003",
+        okrOwnership: ["O1-KR3"],
+    },
+    {
+        name: "TBD Engineer 4",
+        email: "engineer4@chapterhouse.example",
+        role: "engineer",
+        entraObjectId: "00000000-0000-0000-0000-000000000004",
+        okrOwnership: ["O2-KR2"],
+    },
+    {
+        name: "TBD Engineer 5",
+        email: "engineer5@chapterhouse.example",
+        role: "engineer",
+        entraObjectId: "00000000-0000-0000-0000-000000000005",
+        okrOwnership: ["O2-KR3"],
+    },
+];
+function generateOnboardingPage() {
+    return [
+        "# Team Onboarding",
+        "",
+        "Welcome to the Team Chapterhouse wiki. This space is the authoritative team source for OKRs, KPIs, and operating notes that sync down to personal Chapterhouse instances.",
+        "",
+        "## Get oriented",
+        "1. Review `pages/okrs/2026-Q2.md` to understand the current quarterly objectives and the key results you own.",
+        "2. Review `pages/kpis/team.md` to see the operational metrics the team uses for weekly and monthly health checks.",
+        "3. Review `pages/team/index.md` and replace the placeholder roster with the current team membership and KR ownership.",
+        "",
+        "## Log OKR updates",
+        "1. Add daily or milestone progress through Chapterhouse so updates land in `pages/okrs/updates/YYYY-MM-DD.md`.",
+        "2. Reference the KR ID you moved, describe the activity completed, and include notes for blockers or dependencies.",
+        "3. Update the quarterly OKR page when `Current` values change materially so the team report reflects the latest status.",
+        "",
+        "## Set up your personal Chapterhouse instance",
+        "1. Install and authenticate Chapterhouse locally.",
+        "2. Configure your personal instance to sync team wiki paths for `pages/team`, `pages/okrs`, `pages/kpis`, and `pages/shared`.",
+        "3. Confirm your personal Chapterhouse instance can read the seeded team pages before you begin logging updates.",
+        "",
+    ].join("\n");
+}
+function generateSharedReadme() {
+    return [
+        "# Shared Team Knowledge",
+        "",
+        "This space is for team notes, decisions, runbooks, and any knowledge the whole team should have.",
+        "Anyone on the team can contribute. Changes are synced to all personal Chapterhouse instances.",
+        "",
+        "- [OKRs](../okrs/2026-Q2.md)",
+        "- [Team KPIs](../kpis/team.md)",
+        "",
+    ].join("\n");
+}
+function writePageIfMissing(definition) {
+    if (readPage(definition.path) === undefined) {
+        writePage(definition.path, definition.content);
+        return true;
+    }
+    return false;
+}
+function upsertIndexEntry(definition) {
+    const entry = buildIndexEntryForPage(definition.path, definition.fallbackEntry);
+    if (entry) {
+        addToIndex(entry);
+    }
+}
+export function seedTeamWiki() {
+    ensureWikiStructure();
+    const pages = [
+        {
+            path: "pages/okrs/2026-Q2.md",
+            content: generateOKRQuarterPage("2026-Q2", SAMPLE_OBJECTIVES),
+            fallbackEntry: {
+                path: "pages/okrs/2026-Q2.md",
+                title: "OKRs — 2026 Q2",
+                summary: "Q2 2026 team objectives and key results for the Azure platform team.",
+                section: "Team",
+                tags: ["team", "okrs", "2026-q2"],
+            },
+        },
+        {
+            path: "pages/kpis/team.md",
+            content: generateKPIPage(SAMPLE_KPIS),
+            fallbackEntry: {
+                path: "pages/kpis/team.md",
+                title: "Team KPIs",
+                summary: "Shared delivery, reliability, and cost metrics for the team.",
+                section: "Team",
+                tags: ["team", "kpis"],
+            },
+        },
+        {
+            path: "pages/team/index.md",
+            content: generateTeamIndexPage(PLACEHOLDER_MEMBERS),
+            fallbackEntry: {
+                path: "pages/team/index.md",
+                title: "Team Directory",
+                summary: "Placeholder team roster with role, identity, and KR ownership fields.",
+                section: "Team",
+                tags: ["team", "directory"],
+            },
+        },
+        {
+            path: "pages/team/onboarding.md",
+            content: generateOnboardingPage(),
+            fallbackEntry: {
+                path: "pages/team/onboarding.md",
+                title: "Team Onboarding",
+                summary: "How new team members use Chapterhouse, track OKRs, and sync their personal instance.",
+                section: "Team",
+                tags: ["team", "onboarding"],
+            },
+        },
+        {
+            path: "pages/shared/README.md",
+            content: generateSharedReadme(),
+            fallbackEntry: {
+                path: "pages/shared/README.md",
+                title: "Shared Team Knowledge",
+                summary: "Shared team notes, decisions, and runbooks that sync to every personal Chapterhouse instance.",
+                section: "Team",
+                tags: ["team", "shared", "runbooks"],
+            },
+        },
+    ];
+    const created = [];
+    const existing = [];
+    for (const page of pages) {
+        const wasCreated = writePageIfMissing(page);
+        if (wasCreated) {
+            created.push(page.path);
+        }
+        else {
+            existing.push(page.path);
+        }
+        upsertIndexEntry(page);
+    }
+    return { created, existing };
+}
+async function main() {
+    const result = seedTeamWiki();
+    const message = result.created.length > 0
+        ? `Seeded ${result.created.length} team wiki page(s): ${result.created.join(", ")}`
+        : "Team wiki seed already up to date; no pages created.";
+    console.log(`[chapterhouse] ${message}`);
+}
+const invokedPath = process.argv[1] ? resolve(process.argv[1]) : "";
+const modulePath = fileURLToPath(import.meta.url);
+if (invokedPath === modulePath) {
+    main().catch((err) => {
+        console.error("[chapterhouse] Failed to seed team wiki:", err);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=seed-team-wiki.js.map

package/dist/wiki/seed-team-wiki.test.js

@@ -0,0 +1,69 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFile } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import test from "node:test";
+const execFileAsync = promisify(execFile);
+const seedScriptPath = fileURLToPath(new URL("./seed-team-wiki.js", import.meta.url));
+function wikiPath(root, ...parts) {
+    return join(root, ".chapterhouse", "wiki", ...parts);
+}
+test("seed-team-wiki script creates starter OKR, KPI, team, shared, and onboarding pages", async () => {
+    const chapterhouseHomeRoot = mkdtempSync(join(tmpdir(), "chapterhouse-seed-team-wiki-"));
+    try {
+        await execFileAsync(process.execPath, [seedScriptPath], {
+            cwd: process.cwd(),
+            env: {
+                ...process.env,
+                CHAPTERHOUSE_HOME: chapterhouseHomeRoot,
+            },
+        });
+        const okrPage = readFileSync(wikiPath(chapterhouseHomeRoot, "pages", "okrs", "2026-Q2.md"), "utf-8");
+        const kpiPage = readFileSync(wikiPath(chapterhouseHomeRoot, "pages", "kpis", "team.md"), "utf-8");
+        const sharedReadme = readFileSync(wikiPath(chapterhouseHomeRoot, "pages", "shared", "README.md"), "utf-8");
+        const teamIndex = readFileSync(wikiPath(chapterhouseHomeRoot, "pages", "team", "index.md"), "utf-8");
+        const onboarding = readFileSync(wikiPath(chapterhouseHomeRoot, "pages", "team", "onboarding.md"), "utf-8");
+        assert.match(okrPage, /^# OKRs — 2026 Q2/m);
+        assert.match(okrPage, /## O1:/);
+        assert.match(okrPage, /### O2-KR3:/);
+        assert.match(kpiPage, /^# Team KPIs/m);
+        assert.match(kpiPage, /\| KPI \| Owner \| Target \| Current \| Unit \| Frequency \|/);
+        assert.match(sharedReadme, /^# Shared Team Knowledge/m);
+        assert.match(sharedReadme, /Anyone on the team can contribute\./i);
+        assert.match(sharedReadme, /\.\.\/okrs\/2026-Q2\.md/);
+        assert.match(teamIndex, /^# Team Directory/m);
+        assert.match(teamIndex, /TBD Engineer 5/);
+        assert.match(onboarding, /^# Team Onboarding/m);
+        assert.match(onboarding, /set up your personal Chapterhouse instance/i);
+        assert.match(onboarding, /log OKR updates/i);
+    }
+    finally {
+        rmSync(chapterhouseHomeRoot, { recursive: true, force: true });
+    }
+});
+test("seed-team-wiki script is idempotent and preserves existing pages", async () => {
+    const chapterhouseHomeRoot = mkdtempSync(join(tmpdir(), "chapterhouse-seed-team-wiki-idempotent-"));
+    const existingOnboarding = "# Team Onboarding\n\nKeep this custom onboarding guide.\n";
+    try {
+        mkdirSync(wikiPath(chapterhouseHomeRoot, "pages", "team"), { recursive: true });
+        writeFileSync(wikiPath(chapterhouseHomeRoot, "pages", "team", "onboarding.md"), existingOnboarding, "utf-8");
+        await execFileAsync(process.execPath, [seedScriptPath], {
+            cwd: process.cwd(),
+            env: {
+                ...process.env,
+                CHAPTERHOUSE_HOME: chapterhouseHomeRoot,
+            },
+        });
+        assert.equal(readFileSync(wikiPath(chapterhouseHomeRoot, "pages", "team", "onboarding.md"), "utf-8"), existingOnboarding);
+        assert.match(readFileSync(wikiPath(chapterhouseHomeRoot, "pages", "okrs", "2026-Q2.md"), "utf-8"), /^# OKRs — 2026 Q2/m);
+        assert.match(readFileSync(wikiPath(chapterhouseHomeRoot, "pages", "kpis", "team.md"), "utf-8"), /^# Team KPIs/m);
+        assert.match(readFileSync(wikiPath(chapterhouseHomeRoot, "pages", "shared", "README.md"), "utf-8"), /^# Shared Team Knowledge/m);
+    }
+    finally {
+        rmSync(chapterhouseHomeRoot, { recursive: true, force: true });
+    }
+});
+//# sourceMappingURL=seed-team-wiki.test.js.map

package/dist/wiki/team-sync.js

@@ -0,0 +1,212 @@
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { config } from "../config.js";
+import { WIKI_DIR } from "../paths.js";
+import { assertPagePath, readPage, writePage, writeFileAtomic } from "./fs.js";
+import { addToIndex, buildIndexEntryForPage } from "./index-manager.js";
+export class TeamWikiSync {
+    teamChapterhouseUrl;
+    teamChapterhouseToken;
+    standaloneMode;
+    cacheTtlMinutes;
+    teamWikiPaths;
+    wikiDir;
+    cacheRoot;
+    manifestPath;
+    fetchImpl;
+    warn;
+    now;
+    constructor(options = {}) {
+        this.teamChapterhouseUrl = (options.teamChapterhouseUrl ?? config.teamChapterhouseUrl).trim().replace(/\/+$/, "");
+        this.teamChapterhouseToken = (options.teamChapterhouseToken ?? config.teamChapterhouseToken).trim();
+        this.standaloneMode = options.standaloneMode ?? config.standaloneMode;
+        this.cacheTtlMinutes = options.cacheTtlMinutes ?? config.teamWikiCacheTtlMinutes;
+        this.teamWikiPaths = (options.teamWikiPaths ?? config.teamWikiPaths)
+            .map((path) => path.trim().replace(/\/+$/, ""))
+            .filter(Boolean);
+        this.wikiDir = options.wikiDir ?? WIKI_DIR;
+        this.cacheRoot = join(this.wikiDir, ".team-cache");
+        this.manifestPath = join(this.cacheRoot, "manifest.json");
+        this.fetchImpl = options.fetchImpl ?? fetch;
+        this.warn = options.warn ?? ((message) => console.warn(message));
+        this.now = options.now ?? (() => new Date());
+    }
+    isEnabled() {
+        return !this.standaloneMode && this.teamChapterhouseUrl.length > 0;
+    }
+    isTeamPath(path) {
+        return this.teamWikiPaths.some((prefix) => path === prefix || path.startsWith(`${prefix}/`));
+    }
+    async fetchPage(path, options = {}) {
+        assertPagePath(path);
+        if (!this.isEnabled() || !this.isTeamPath(path)) {
+            return null;
+        }
+        const manifest = this.readManifest();
+        const cachedContent = this.readCachedContent(path);
+        const manifestEntry = manifest[path];
+        if (cachedContent !== undefined && manifestEntry && this.isFresh(manifestEntry)) {
+            return cachedContent;
+        }
+        try {
+            const response = await this.fetchImpl(this.buildPageUrl(path), {
+                headers: this.buildHeaders(options.authorizationHeader),
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}`);
+            }
+            const payload = await response.json();
+            if (!payload.exists) {
+                this.deleteCache(path, manifest);
+                return null;
+            }
+            this.writeCachedContent(path, payload.content);
+            manifest[path] = {
+                fetchedAt: this.now().toISOString(),
+                etag: response.headers.get("etag") ?? undefined,
+            };
+            this.writeManifest(manifest);
+            return payload.content;
+        }
+        catch (err) {
+            if (cachedContent !== undefined) {
+                this.warn(`[wiki] Failed to refresh team wiki page "${path}"; serving stale cache. ${err instanceof Error ? err.message : String(err)}`);
+                return cachedContent;
+            }
+            return null;
+        }
+    }
+    async syncAll(options = {}) {
+        if (!this.isEnabled()) {
+            return [];
+        }
+        const response = await this.fetchImpl(this.buildListUrl(), {
+            headers: this.buildHeaders(options.authorizationHeader),
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to list team wiki pages: HTTP ${response.status}`);
+        }
+        const payload = await response.json();
+        const synced = [];
+        for (const path of payload.pages) {
+            if (!this.isTeamPath(path)) {
+                continue;
+            }
+            const content = await this.fetchPage(path, options);
+            if (content !== null) {
+                writePage(path, content);
+                const entry = buildIndexEntryForPage(path, { section: "Team" });
+                if (entry) {
+                    addToIndex(entry);
+                }
+                synced.push(path);
+            }
+        }
+        return synced;
+    }
+    async pushUpdate(payload, options = {}) {
+        if (!this.isEnabled()) {
+            return {
+                ok: false,
+                disabled: true,
+                payload,
+            };
+        }
+        const response = await this.fetchImpl(`${this.teamChapterhouseUrl}/api/team/update`, {
+            method: "POST",
+            headers: {
+                ...this.buildHeaders(options.authorizationHeader),
+                "content-type": "application/json",
+            },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to push team update: HTTP ${response.status}`);
+        }
+        return await response.json();
+    }
+    buildPageUrl(path) {
+        return `${this.teamChapterhouseUrl}/api/team/wiki/${encodeURIComponent(path)}`;
+    }
+    buildListUrl() {
+        return `${this.teamChapterhouseUrl}/api/team/wiki`;
+    }
+    buildHeaders(authorizationHeader) {
+        const headers = {
+            accept: "application/json",
+        };
+        const header = authorizationHeader?.trim() || this.normalizeTokenHeader(this.teamChapterhouseToken);
+        if (header) {
+            headers.authorization = header;
+        }
+        return headers;
+    }
+    normalizeTokenHeader(token) {
+        if (!token) {
+            return undefined;
+        }
+        return token.startsWith("Bearer ") ? token : `Bearer ${token}`;
+    }
+    isFresh(entry) {
+        const fetchedAtMs = Date.parse(entry.fetchedAt);
+        if (!Number.isFinite(fetchedAtMs)) {
+            return false;
+        }
+        return this.now().getTime() - fetchedAtMs < this.cacheTtlMinutes * 60 * 1000;
+    }
+    readManifest() {
+        if (!existsSync(this.manifestPath)) {
+            return {};
+        }
+        try {
+            const parsed = JSON.parse(readFileSync(this.manifestPath, "utf-8"));
+            return typeof parsed === "object" && parsed !== null ? parsed : {};
+        }
+        catch {
+            return {};
+        }
+    }
+    writeManifest(manifest) {
+        mkdirSync(this.cacheRoot, { recursive: true });
+        writeFileAtomic(this.manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+    }
+    readCachedContent(path) {
+        const cachePath = this.cacheFilePath(path);
+        if (!existsSync(cachePath)) {
+            return undefined;
+        }
+        return readFileSync(cachePath, "utf-8");
+    }
+    writeCachedContent(path, content) {
+        const cachePath = this.cacheFilePath(path);
+        mkdirSync(dirname(cachePath), { recursive: true });
+        writeFileAtomic(cachePath, content);
+    }
+    deleteCache(path, manifest) {
+        const cachePath = this.cacheFilePath(path);
+        if (existsSync(cachePath)) {
+            rmSync(cachePath, { force: true });
+        }
+        if (manifest[path]) {
+            delete manifest[path];
+            this.writeManifest(manifest);
+        }
+    }
+    cacheFilePath(path) {
+        return join(this.cacheRoot, path);
+    }
+}
+export const teamWikiSync = new TeamWikiSync();
+export async function readWikiPage(path, options = {}) {
+    const shouldUseTeamSync = teamWikiSync.isEnabled()
+        && path.startsWith("pages/")
+        && teamWikiSync.isTeamPath(path);
+    if (shouldUseTeamSync) {
+        const remoteContent = await teamWikiSync.fetchPage(path, options);
+        if (remoteContent !== null) {
+            return remoteContent;
+        }
+    }
+    return readPage(path);
+}
+//# sourceMappingURL=team-sync.js.map