chapterhouse 0.9.2 → 0.11.0

package/dist/api/routes/memory.js

@@ -0,0 +1,299 @@
+import { Router } from "express";
+import { z } from "zod";
+import { getActiveScope, setActiveScope } from "../../memory/active-scope.js";
+import { recordDecision } from "../../memory/decisions.js";
+import { upsertEntity } from "../../memory/entities.js";
+import { handleGitCommitHook, handlePrMergeHook } from "../../memory/hooks.js";
+import { getInboxItem, listPendingInboxItems, resolveInboxItem } from "../../memory/inbox.js";
+import { recordObservation } from "../../memory/observations.js";
+import { createScope, getScope, listScopes } from "../../memory/scopes.js";
+import { ActiveMemoryScopeSchema, InboxRouteResponseSchema, MemoryEntriesSchema, MemoryHookResponseSchema, MemoryInboxSchema, MemoryRememberResponseSchema, MemoryScopeCreateResponseSchema, MemoryScopeListSchema, SetActiveScopeResponseSchema, } from "../../shared/api-schemas.js";
+import { getDb } from "../../store/db.js";
+import { childLogger } from "../../util/logger.js";
+import { parseRequest } from "../errors.js";
+import { sendJson } from "../send-json.js";
+const log = childLogger("server");
+const requiredString = (message) => z.string({ error: message }).trim().min(1, message);
+const scopeCreateSchema = z.object({
+    slug: requiredString("Missing 'slug' in request body")
+        .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Scope slug must be unique kebab-case"),
+    title: requiredString("Missing 'title' in request body"),
+    description: z.string().optional(),
+}).strict();
+const setActiveScopeSchema = z.object({
+    scope: z.string().nullable(),
+});
+const memoryEntriesQuerySchema = z.object({
+    store: z.enum(["observations", "decisions", "entities", "action_items"]).optional(),
+    tier: z.enum(["hot", "warm", "cold"]).optional(),
+    cursor: z.string().regex(/^\d+$/, "cursor must be a positive integer").optional(),
+    limit: z.coerce.number().int().min(1).max(100).optional(),
+});
+const memoryRememberSchema = z.object({
+    content: requiredString("Missing 'content' in request body"),
+    kind: z.enum(["observation", "decision"]).optional(),
+    entity_name: z.string().optional(),
+    entity_kind: z.string().optional(),
+    title: z.string().optional(),
+    decided_at: z.string().optional(),
+    tier: z.enum(["hot", "warm", "cold"]).optional(),
+});
+const inboxRouteSchema = z.object({
+    action: z.enum(["accept", "reject", "route"]),
+    reason: z.string().optional(),
+    target_scope: z.string().optional(),
+});
+const gitCommitHookSchema = z.object({
+    message: requiredString("Missing 'message' in request body"),
+    stat: z.string().optional(),
+});
+const prMergeHookSchema = z.object({
+    number: z.number({ error: "Missing or invalid 'number' in request body" }).int().positive(),
+    title: requiredString("Missing 'title' in request body"),
+    body: z.string().optional(),
+    files_changed: z.array(z.string()).optional(),
+});
+export function createMemoryRouter(options) {
+    const { authMiddleware } = options;
+    const router = Router();
+    router.get("/api/memory/active-scope", (_req, res) => {
+        const activeScope = getActiveScope();
+        if (!activeScope) {
+            sendJson(res, ActiveMemoryScopeSchema, null);
+            return;
+        }
+        sendJson(res, ActiveMemoryScopeSchema, {
+            slug: activeScope.slug,
+            title: activeScope.title,
+        });
+    });
+    router.post("/api/memory/active-scope", (req, res) => {
+        const body = parseRequest(setActiveScopeSchema, req.body ?? {});
+        try {
+            const scope = setActiveScope(body.scope);
+            sendJson(res, SetActiveScopeResponseSchema, { ok: true, scope: scope?.slug ?? null });
+        }
+        catch (err) {
+            res.status(404).json({ error: err instanceof Error ? err.message : String(err) });
+        }
+    });
+    router.get("/api/memory/scopes", (_req, res) => {
+        const db = getDb();
+        const activeScope = getActiveScope();
+        const scopes = listScopes();
+        const result = scopes.map((scope) => {
+            const counts = {
+                observations: db.prepare(`SELECT COUNT(*) AS count FROM mem_observations WHERE scope_id = ?`).get(scope.id).count,
+                decisions: db.prepare(`SELECT COUNT(*) AS count FROM mem_decisions WHERE scope_id = ?`).get(scope.id).count,
+                entities: db.prepare(`SELECT COUNT(*) AS count FROM mem_entities WHERE scope_id = ?`).get(scope.id).count,
+                action_items: db.prepare(`SELECT COUNT(*) AS count FROM mem_action_items WHERE scope_id = ?`).get(scope.id).count,
+            };
+            return {
+                slug: scope.slug,
+                title: scope.title,
+                description: scope.description,
+                active: activeScope?.slug === scope.slug,
+                counts,
+            };
+        });
+        sendJson(res, MemoryScopeListSchema, { scopes: result });
+    });
+    router.get("/api/memory/inbox", (_req, res) => {
+        const items = listPendingInboxItems();
+        const result = items.map((item) => ({
+            id: item.id,
+            scope_slug: item.scopeId
+                ? getDb().prepare(`SELECT slug FROM mem_scopes WHERE id = ?`).get(item.scopeId)?.slug ?? null
+                : null,
+            kind: item.kind,
+            payload: item.payload,
+            source_agent: item.sourceAgent,
+            created_at: item.createdAt,
+        }));
+        sendJson(res, MemoryInboxSchema, { items: result, total: result.length });
+    });
+    router.post("/api/memory/inbox/:id/route", (req, res) => {
+        const id = Number(req.params.id);
+        if (!Number.isInteger(id) || id <= 0) {
+            res.status(400).json({ error: "Invalid inbox item id" });
+            return;
+        }
+        const body = parseRequest(inboxRouteSchema, req.body ?? {});
+        const item = getInboxItem(id);
+        if (!item) {
+            res.status(404).json({ error: `Inbox item '${id}' not found` });
+            return;
+        }
+        if (item.status !== "pending") {
+            res.status(409).json({ error: `Inbox item '${id}' is already resolved` });
+            return;
+        }
+        const status = body.action === "accept" ? "accepted" : "rejected";
+        const reason = body.reason ?? (body.action === "accept" ? "Accepted via web UI" : "Rejected via web UI");
+        resolveInboxItem(id, status, reason);
+        log.info({ id, action: body.action }, "inbox item routed via web UI");
+        sendJson(res, InboxRouteResponseSchema, { ok: true });
+    });
+    router.get("/api/memory/:scope", (req, res) => {
+        const scopeSlug = String(req.params.scope);
+        const scope = getScope(scopeSlug);
+        if (!scope) {
+            res.status(404).json({ error: `Memory scope '${scopeSlug}' not found` });
+            return;
+        }
+        const query = parseRequest(memoryEntriesQuerySchema, req.query);
+        const store = query.store ?? "observations";
+        const tier = query.tier;
+        const cursor = query.cursor ? Number(query.cursor) : undefined;
+        const limit = query.limit ?? 100;
+        const db = getDb();
+        let entries;
+        let total;
+        let nextCursor;
+        if (store === "observations") {
+            const cursorClause = cursor ? "AND id < ?" : "";
+            const params = tier ? [scope.id, tier] : [scope.id];
+            const pageParams = cursor ? [...params, cursor, limit + 1] : [...params, limit + 1];
+            if (tier) {
+                entries = db.prepare(`SELECT id, content, source, tier, entity_id, created_at FROM mem_observations WHERE scope_id = ? AND tier = ? AND archived_at IS NULL ${cursorClause} ORDER BY id DESC LIMIT ?`).all(...pageParams);
+                total = db.prepare(`SELECT COUNT(*) AS n FROM mem_observations WHERE scope_id = ? AND tier = ? AND archived_at IS NULL`).get(scope.id, tier).n;
+            }
+            else {
+                entries = db.prepare(`SELECT id, content, source, tier, entity_id, created_at FROM mem_observations WHERE scope_id = ? AND archived_at IS NULL ${cursorClause} ORDER BY id DESC LIMIT ?`).all(...pageParams);
+                total = db.prepare(`SELECT COUNT(*) AS n FROM mem_observations WHERE scope_id = ? AND archived_at IS NULL`).get(scope.id).n;
+            }
+        }
+        else if (store === "decisions") {
+            const cursorClause = cursor ? "AND id < ?" : "";
+            const params = tier ? [scope.id, tier] : [scope.id];
+            const pageParams = cursor ? [...params, cursor, limit + 1] : [...params, limit + 1];
+            if (tier) {
+                entries = db.prepare(`SELECT id, title, rationale, tier, entity_id, decided_at, created_at FROM mem_decisions WHERE scope_id = ? AND tier = ? AND archived_at IS NULL ${cursorClause} ORDER BY id DESC LIMIT ?`).all(...pageParams);
+                total = db.prepare(`SELECT COUNT(*) AS n FROM mem_decisions WHERE scope_id = ? AND tier = ? AND archived_at IS NULL`).get(scope.id, tier).n;
+            }
+            else {
+                entries = db.prepare(`SELECT id, title, rationale, tier, entity_id, decided_at, created_at FROM mem_decisions WHERE scope_id = ? AND archived_at IS NULL ${cursorClause} ORDER BY id DESC LIMIT ?`).all(...pageParams);
+                total = db.prepare(`SELECT COUNT(*) AS n FROM mem_decisions WHERE scope_id = ? AND archived_at IS NULL`).get(scope.id).n;
+            }
+        }
+        else if (store === "entities") {
+            const cursorClause = cursor ? "AND id < ?" : "";
+            const params = tier ? [scope.id, tier] : [scope.id];
+            const pageParams = cursor ? [...params, cursor, limit + 1] : [...params, limit + 1];
+            if (tier) {
+                entries = db.prepare(`SELECT id, kind, name, summary, tier, created_at, updated_at FROM mem_entities WHERE scope_id = ? AND tier = ? ${cursorClause} ORDER BY id DESC LIMIT ?`).all(...pageParams);
+                total = db.prepare(`SELECT COUNT(*) AS n FROM mem_entities WHERE scope_id = ? AND tier = ?`).get(scope.id, tier).n;
+            }
+            else {
+                entries = db.prepare(`SELECT id, kind, name, summary, tier, created_at, updated_at FROM mem_entities WHERE scope_id = ? ${cursorClause} ORDER BY id DESC LIMIT ?`).all(...pageParams);
+                total = db.prepare(`SELECT COUNT(*) AS n FROM mem_entities WHERE scope_id = ?`).get(scope.id).n;
+            }
+        }
+        else {
+            const cursorClause = cursor ? "AND id < ?" : "";
+            const params = tier ? [scope.id, tier] : [scope.id];
+            const pageParams = cursor ? [...params, cursor, limit + 1] : [...params, limit + 1];
+            if (tier) {
+                entries = db.prepare(`SELECT id, title, detail, status, tier, due_at, entity_id, created_at FROM mem_action_items WHERE scope_id = ? AND tier = ? ${cursorClause} ORDER BY id DESC LIMIT ?`).all(...pageParams);
+                total = db.prepare(`SELECT COUNT(*) AS n FROM mem_action_items WHERE scope_id = ? AND tier = ?`).get(scope.id, tier).n;
+            }
+            else {
+                entries = db.prepare(`SELECT id, title, detail, status, tier, due_at, entity_id, created_at FROM mem_action_items WHERE scope_id = ? ${cursorClause} ORDER BY id DESC LIMIT ?`).all(...pageParams);
+                total = db.prepare(`SELECT COUNT(*) AS n FROM mem_action_items WHERE scope_id = ?`).get(scope.id).n;
+            }
+        }
+        if (entries.length > limit) {
+            const extra = entries.pop();
+            const last = entries[entries.length - 1];
+            nextCursor = String(last?.id ?? extra?.id ?? "");
+        }
+        sendJson(res, MemoryEntriesSchema, { entries: entries, total, ...(nextCursor ? { nextCursor } : {}) });
+    });
+    router.post("/api/memory/:scope/remember", (req, res) => {
+        const scopeSlug = String(req.params.scope);
+        const scope = getScope(scopeSlug);
+        if (!scope) {
+            res.status(404).json({ error: `Memory scope '${scopeSlug}' not found` });
+            return;
+        }
+        const body = parseRequest(memoryRememberSchema, req.body ?? {});
+        if (body.entity_name && !body.entity_kind) {
+            res.status(400).json({ error: "entity_kind is required when entity_name is provided" });
+            return;
+        }
+        const kind = body.kind ?? "observation";
+        const entity = body.entity_name
+            ? upsertEntity({
+                scope_id: scope.id,
+                kind: body.entity_kind,
+                name: body.entity_name,
+                tier: body.tier ?? "warm",
+            })
+            : undefined;
+        if (kind === "decision") {
+            if (!body.title) {
+                res.status(400).json({ error: "title is required when kind='decision'" });
+                return;
+            }
+            const decision = recordDecision({
+                scope_id: scope.id,
+                entity_id: entity?.id,
+                title: body.title,
+                rationale: body.content,
+                decided_at: body.decided_at ?? new Date().toISOString().slice(0, 10),
+                tier: body.tier ?? "warm",
+            });
+            log.info({ id: decision.id, scope: scopeSlug, kind }, "memory written via web UI");
+            sendJson(res, MemoryRememberResponseSchema, { ok: true, id: String(decision.id) });
+            return;
+        }
+        const observation = recordObservation({
+            scope_id: scope.id,
+            entity_id: entity?.id,
+            content: body.content,
+            source: "agent:web-ui",
+            tier: body.tier ?? "warm",
+        });
+        log.info({ id: observation.id, scope: scopeSlug, kind }, "memory written via web UI");
+        sendJson(res, MemoryRememberResponseSchema, { ok: true, id: String(observation.id) });
+    });
+    router.post("/api/memory/hooks/git-commit", authMiddleware, (req, res, next) => {
+        const body = parseRequest(gitCommitHookSchema, req.body ?? {});
+        handleGitCommitHook({ message: body.message, stat: body.stat })
+            .then((result) => sendJson(res, MemoryHookResponseSchema, { ok: true, observation_id: result.observation_id }))
+            .catch(next);
+    });
+    router.post("/api/memory/hooks/pr-merge", authMiddleware, (req, res, next) => {
+        const body = parseRequest(prMergeHookSchema, req.body ?? {});
+        handlePrMergeHook({
+            number: body.number,
+            title: body.title,
+            body: body.body,
+            files_changed: body.files_changed,
+        })
+            .then((result) => sendJson(res, MemoryHookResponseSchema, { ok: true, observation_id: result.observation_id }))
+            .catch(next);
+    });
+    router.post("/api/scopes", (req, res) => {
+        const body = parseRequest(scopeCreateSchema, req.body ?? {});
+        if (getScope(body.slug)) {
+            res.status(409).json({ error: `Memory scope '${body.slug}' already exists` });
+            return;
+        }
+        const scope = createScope({
+            slug: body.slug,
+            title: body.title,
+            description: body.description ?? "",
+            keywords: [body.slug],
+        });
+        res.status(201);
+        sendJson(res, MemoryScopeCreateResponseSchema, {
+            slug: scope.slug,
+            title: scope.title,
+            description: scope.description,
+            active: scope.active,
+        });
+    });
+    return router;
+}
+//# sourceMappingURL=memory.js.map

package/dist/api/routes/projects.js

@@ -0,0 +1,170 @@
+import { Router } from "express";
+import { existsSync, statSync } from "fs";
+import { z } from "zod";
+import { ProjectDeleteResponseSchema, ProjectDetailSchema, ProjectListSchema } from "../../shared/api-schemas.js";
+import { ensureWikiStructure, pageExists, writePage, deletePage } from "../../wiki/fs.js";
+import { withWikiWrite } from "../../wiki/lock.js";
+import { loadRegistry, normalizeProjectPath, saveRegistry } from "../../wiki/project-registry.js";
+import { getProjectRulesPath, listTopLevelSoftRules, loadProjectRules, loadProjectRuleSummary, renderInitialProjectRulesPage, saveProjectRulesHardFields, saveProjectRulesSoftRules, } from "../../wiki/project-rules.js";
+import { BadRequestError, ForbiddenError, NotFoundError, parseRequest } from "../errors.js";
+import { sendJson } from "../send-json.js";
+const requiredString = (message) => z.string({ error: message }).trim().min(1, message);
+const projectCreateSchema = z.object({
+    slug: requiredString("Missing 'slug' in request body")
+        .regex(/^[a-z0-9][a-z0-9-]*$/, "Project slug must be a lowercase slug"),
+    cwd: requiredString("Missing 'cwd' in request body")
+        .refine((value) => value.startsWith("/"), "Project cwd must be an absolute path"),
+}).strict();
+const projectHardRulesSchema = z.object({
+    hardRules: z.object({
+        auto_pr: z.boolean({ error: "hardRules.auto_pr must be a boolean" }),
+        require_worktree: z.boolean({ error: "hardRules.require_worktree must be a boolean" }),
+        pr_draft_default: z.boolean({ error: "hardRules.pr_draft_default must be a boolean" }),
+        default_branch: requiredString("hardRules.default_branch must be a non-empty string"),
+        commit_co_author: requiredString("hardRules.commit_co_author must be a non-empty string"),
+        test_command: z.string({ error: "hardRules.test_command must be a string" }),
+        build_command: z.string({ error: "hardRules.build_command must be a string" }),
+        lint_command: z.string({ error: "hardRules.lint_command must be a string" }),
+        require_clean_worktree: z.boolean({ error: "hardRules.require_clean_worktree must be a boolean" }),
+    }).strict(),
+}).strict();
+const projectSoftRulesSchema = z.object({
+    softRules: z.array(requiredString("softRules entries must be non-empty strings")),
+}).strict();
+function assertProjectCwdDirectory(cwd) {
+    if (!existsSync(cwd) || !statSync(cwd).isDirectory()) {
+        throw new BadRequestError("Project cwd must exist and be a directory");
+    }
+}
+function createProjectDetailPayload(slug, cwd) {
+    const rules = loadProjectRules(slug);
+    if (!rules.found) {
+        return {
+            slug,
+            cwd,
+            rulesFound: false,
+            hardRules: null,
+            softRules: [],
+        };
+    }
+    return {
+        slug,
+        cwd,
+        rulesFound: true,
+        hardRules: rules.hard,
+        softRules: listTopLevelSoftRules(rules.soft),
+    };
+}
+export function createProjectsRouter(options) {
+    const { modeContext } = options;
+    const router = Router();
+    function assertProjectRegistryMutationAllowed(req) {
+        if (modeContext.isTeam() && req.user?.role !== "team-lead") {
+            throw new ForbiddenError("Forbidden");
+        }
+    }
+    router.get("/api/projects", (_req, res) => {
+        ensureWikiStructure();
+        const projects = Object.entries(loadRegistry())
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([slug, cwd]) => {
+            const summary = loadProjectRuleSummary(slug);
+            return {
+                slug,
+                cwd,
+                hardRuleCount: summary.hardRuleCount,
+                softRuleCount: summary.softRuleCount,
+            };
+        });
+        sendJson(res, ProjectListSchema, projects);
+    });
+    router.get("/api/projects/:slug", (req, res) => {
+        ensureWikiStructure();
+        const slugParam = req.params.slug;
+        const slug = Array.isArray(slugParam) ? (slugParam[0] ?? "") : (slugParam ?? "");
+        const cwd = loadRegistry()[slug];
+        if (!cwd) {
+            res.status(404).json({ error: "Project not found" });
+            return;
+        }
+        sendJson(res, ProjectDetailSchema, createProjectDetailPayload(slug, cwd));
+    });
+    router.post("/api/projects", async (req, res) => {
+        ensureWikiStructure();
+        assertProjectRegistryMutationAllowed(req);
+        const { slug, cwd } = parseRequest(projectCreateSchema, req.body ?? {});
+        const normalizedCwd = normalizeProjectPath(cwd);
+        const rulesPath = getProjectRulesPath(slug);
+        await withWikiWrite(() => {
+            const registry = loadRegistry();
+            if (registry[slug]) {
+                throw new BadRequestError(`Project '${slug}' already exists`);
+            }
+            if (pageExists(rulesPath)) {
+                throw new BadRequestError(`Project rules page '${rulesPath}' already exists`);
+            }
+            assertProjectCwdDirectory(normalizedCwd);
+            saveRegistry({
+                ...registry,
+                [slug]: normalizedCwd,
+            });
+            writePage(rulesPath, renderInitialProjectRulesPage(slug));
+        });
+        res.status(201);
+        sendJson(res, ProjectDetailSchema, createProjectDetailPayload(slug, normalizedCwd));
+    });
+    router.delete("/api/projects/:slug", async (req, res) => {
+        ensureWikiStructure();
+        assertProjectRegistryMutationAllowed(req);
+        const slugParam = req.params.slug;
+        const slug = Array.isArray(slugParam) ? (slugParam[0] ?? "") : (slugParam ?? "");
+        const registry = loadRegistry();
+        if (!registry[slug]) {
+            throw new NotFoundError("Project not found");
+        }
+        const rulesPath = getProjectRulesPath(slug);
+        await withWikiWrite(() => {
+            const nextRegistry = { ...loadRegistry() };
+            delete nextRegistry[slug];
+            saveRegistry(nextRegistry);
+            deletePage(rulesPath);
+        });
+        sendJson(res, ProjectDeleteResponseSchema, { ok: true, slug });
+    });
+    router.put("/api/projects/:slug/rules/hard", async (req, res) => {
+        ensureWikiStructure();
+        const slugParam = req.params.slug;
+        const slug = Array.isArray(slugParam) ? (slugParam[0] ?? "") : (slugParam ?? "");
+        const cwd = loadRegistry()[slug];
+        if (!cwd) {
+            throw new NotFoundError("Project not found");
+        }
+        if (!pageExists(getProjectRulesPath(slug))) {
+            throw new NotFoundError("Project rules not found");
+        }
+        const { hardRules } = parseRequest(projectHardRulesSchema, req.body ?? {});
+        await withWikiWrite(() => {
+            saveProjectRulesHardFields(slug, hardRules);
+        });
+        sendJson(res, ProjectDetailSchema, createProjectDetailPayload(slug, cwd));
+    });
+    router.put("/api/projects/:slug/rules/soft", async (req, res) => {
+        ensureWikiStructure();
+        const slugParam = req.params.slug;
+        const slug = Array.isArray(slugParam) ? (slugParam[0] ?? "") : (slugParam ?? "");
+        const cwd = loadRegistry()[slug];
+        if (!cwd) {
+            throw new NotFoundError("Project not found");
+        }
+        if (!pageExists(getProjectRulesPath(slug))) {
+            throw new NotFoundError("Project rules not found");
+        }
+        const { softRules } = parseRequest(projectSoftRulesSchema, req.body ?? {});
+        await withWikiWrite(() => {
+            saveProjectRulesSoftRules(slug, softRules);
+        });
+        sendJson(res, ProjectDetailSchema, createProjectDetailPayload(slug, cwd));
+    });
+    return router;
+}
+//# sourceMappingURL=projects.js.map