chapterhouse 0.3.13 → 0.3.14

package/dist/squad/squad-coordinator-system-message.test.js

@@ -1,190 +0,0 @@
-/**
- * Phase 4 — Squad coordinator system message tests
- *
- * Covers:
- *  - Error thrown when no squad.agent.md found
- *  - Loads from .github/agents/squad.agent.md (primary)
- *  - Loads from squad.agent.md (fallback)
- *  - Includes project charter from .squad/team.md
- *  - Includes recent decisions from .squad/decisions.md
- *  - Graceful when team.md missing (warning comment, no throw)
- *  - Does NOT include generic Chapterhouse system message sections
- */
-import assert from "node:assert/strict";
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import test from "node:test";
-const repoRoot = process.cwd();
-const sandboxBase = join(repoRoot, ".test-work", `squad-charter-${process.pid}`);
-async function loadCharterModule() {
-    return await import(new URL(`./charter.js?v=${Date.now()}-${Math.random()}`, import.meta.url).href);
-}
-/** Scaffold a minimal project directory structure for testing. */
-function makeProjectDir(name, opts = {}) {
-    const projectRoot = join(sandboxBase, name);
-    mkdirSync(join(projectRoot, ".squad"), { recursive: true });
-    if (opts.githubAgentFile !== undefined) {
-        mkdirSync(join(projectRoot, ".github", "agents"), { recursive: true });
-        writeFileSync(join(projectRoot, ".github", "agents", "squad.agent.md"), opts.githubAgentFile);
-    }
-    if (opts.rootAgentFile !== undefined) {
-        writeFileSync(join(projectRoot, "squad.agent.md"), opts.rootAgentFile);
-    }
-    if (opts.teamMd !== undefined) {
-        writeFileSync(join(projectRoot, ".squad", "team.md"), opts.teamMd);
-    }
-    if (opts.decisionsMd !== undefined) {
-        writeFileSync(join(projectRoot, ".squad", "decisions.md"), opts.decisionsMd);
-    }
-    return projectRoot;
-}
-test.before(() => {
-    mkdirSync(sandboxBase, { recursive: true });
-});
-test.after(() => {
-    rmSync(sandboxBase, { recursive: true, force: true });
-});
-// ---------------------------------------------------------------------------
-// 1. Throws when no squad.agent.md found
-// ---------------------------------------------------------------------------
-test("getSquadCoordinatorSystemMessage throws when no squad.agent.md file exists", async () => {
-    const charter = await loadCharterModule();
-    assert.equal(typeof charter.getSquadCoordinatorSystemMessage, "function", "getSquadCoordinatorSystemMessage should be exported from charter module");
-    const fn = charter.getSquadCoordinatorSystemMessage;
-    const projectRoot = makeProjectDir("no-agent", { teamMd: "# Team" });
-    await assert.rejects(async () => { await fn(projectRoot); }, (err) => {
-        assert.ok(err instanceof Error, "should throw an Error");
-        assert.ok(err.message.toLowerCase().includes("squad.agent.md") || err.message.toLowerCase().includes("agent"), `error message should reference squad.agent.md, got: "${err.message}"`);
-        return true;
-    }, "should reject with a clear error when no squad.agent.md is found");
-});
-// ---------------------------------------------------------------------------
-// 2. Loads from .github/agents/squad.agent.md (primary location)
-// ---------------------------------------------------------------------------
-test("getSquadCoordinatorSystemMessage loads from .github/agents/squad.agent.md", async () => {
-    const charter = await loadCharterModule();
-    const fn = charter.getSquadCoordinatorSystemMessage;
-    const AGENT_CONTENT = "# Squad Coordinator\nYou are the coordinator for this project.";
-    const projectRoot = makeProjectDir("github-agent", {
-        githubAgentFile: AGENT_CONTENT,
-        teamMd: "# Team",
-        decisionsMd: "## Decision A\nUse TypeScript.",
-    });
-    const result = await fn(projectRoot);
-    assert.ok(typeof result === "string", "result should be a string");
-    assert.ok(result.includes("You are the coordinator for this project."), `result should include .github/agents/squad.agent.md content, got: ${result.slice(0, 300)}`);
-});
-// ---------------------------------------------------------------------------
-// 3. Loads from squad.agent.md (fallback when .github/agents/ not present)
-// ---------------------------------------------------------------------------
-test("getSquadCoordinatorSystemMessage falls back to squad.agent.md at project root", async () => {
-    const charter = await loadCharterModule();
-    const fn = charter.getSquadCoordinatorSystemMessage;
-    const AGENT_CONTENT = "# Root Squad Agent\nFallback coordinator instructions.";
-    const projectRoot = makeProjectDir("root-agent", {
-        rootAgentFile: AGENT_CONTENT,
-        teamMd: "# Team",
-    });
-    const result = await fn(projectRoot);
-    assert.ok(result.includes("Fallback coordinator instructions."), `result should include root-level squad.agent.md content, got: ${result.slice(0, 300)}`);
-});
-// ---------------------------------------------------------------------------
-// 4. Includes project charter (.squad/team.md)
-// ---------------------------------------------------------------------------
-test("getSquadCoordinatorSystemMessage includes .squad/team.md content as project charter", async () => {
-    const charter = await loadCharterModule();
-    const fn = charter.getSquadCoordinatorSystemMessage;
-    const TEAM_CONTENT = "# Project Team\n## Members\n- Alice (Lead)\n- Bob (Backend)";
-    const projectRoot = makeProjectDir("with-team", {
-        githubAgentFile: "# Coordinator",
-        teamMd: TEAM_CONTENT,
-        decisionsMd: "## Dec 1\nSome decision.",
-    });
-    const result = await fn(projectRoot);
-    assert.ok(result.includes("Alice (Lead)"), `result should include team.md content, got: ${result.slice(0, 400)}`);
-    assert.ok(result.includes("Bob (Backend)"), `result should include all team members, got: ${result.slice(0, 400)}`);
-});
-// ---------------------------------------------------------------------------
-// 5. Includes recent decisions (.squad/decisions.md)
-// ---------------------------------------------------------------------------
-test("getSquadCoordinatorSystemMessage includes recent decisions from .squad/decisions.md", async () => {
-    const charter = await loadCharterModule();
-    const fn = charter.getSquadCoordinatorSystemMessage;
-    const DECISIONS = "## Decision Alpha\nUse strict TypeScript.\n\n## Decision Beta\nCache with Redis.";
-    const projectRoot = makeProjectDir("with-decisions", {
-        githubAgentFile: "# Coordinator",
-        teamMd: "# Team",
-        decisionsMd: DECISIONS,
-    });
-    const result = await fn(projectRoot);
-    assert.ok(result.includes("Decision Alpha") || result.includes("Use strict TypeScript"), `result should include decisions content, got: ${result.slice(0, 500)}`);
-});
-// ---------------------------------------------------------------------------
-// 6. Graceful when .squad/team.md is missing
-// ---------------------------------------------------------------------------
-test("getSquadCoordinatorSystemMessage does not throw when .squad/team.md is absent, includes warning", async () => {
-    const charter = await loadCharterModule();
-    const fn = charter.getSquadCoordinatorSystemMessage;
-    const projectRoot = makeProjectDir("no-team-md", {
-        githubAgentFile: "# Coordinator",
-        // no teamMd
-        decisionsMd: "## Dec\nsome decision",
-    });
-    let result;
-    await assert.doesNotReject(async () => { result = await fn(projectRoot); }, "should not throw when team.md is missing");
-    assert.ok(typeof result === "string", "should return a string even without team.md");
-    // Should include some indication that team.md is missing
-    assert.ok(result.includes("team.md") || result.toLowerCase().includes("not found") || result.includes("create .squad"), `result should include a warning about missing team.md, got: ${result?.slice(0, 400)}`);
-});
-// ---------------------------------------------------------------------------
-// 7. Does NOT include generic Chapterhouse system message sections
-// ---------------------------------------------------------------------------
-test("getSquadCoordinatorSystemMessage does not include generic Chapterhouse sections", async () => {
-    const charter = await loadCharterModule();
-    const fn = charter.getSquadCoordinatorSystemMessage;
-    const projectRoot = makeProjectDir("no-ch-sections", {
-        githubAgentFile: "# Squad Coordinator\nProject-specific coordinator.",
-        teamMd: "# Team",
-        decisionsMd: "## Dec\nDecision text.",
-    });
-    const result = await fn(projectRoot);
-    // These are markers from the default Chapterhouse orchestrator system message
-    // — they must NOT appear in a Squad coordinator message
-    const forbiddenPhrases = [
-        "You are Chapterhouse",
-        "@mention",
-        "delegate_to_agent",
-    ];
-    for (const phrase of forbiddenPhrases) {
-        assert.equal(result.includes(phrase), false, `result should NOT include Chapterhouse-specific phrase: "${phrase}"`);
-    }
-});
-// ---------------------------------------------------------------------------
-// 8. .github/agents/squad.agent.md takes priority over root squad.agent.md
-// ---------------------------------------------------------------------------
-test("getSquadCoordinatorSystemMessage prefers .github/agents/squad.agent.md over root fallback", async () => {
-    const charter = await loadCharterModule();
-    const fn = charter.getSquadCoordinatorSystemMessage;
-    const projectRoot = makeProjectDir("both-agent-files", {
-        githubAgentFile: "PRIMARY_AGENT_CONTENT",
-        rootAgentFile: "FALLBACK_AGENT_CONTENT",
-        teamMd: "# Team",
-    });
-    const result = await fn(projectRoot);
-    assert.ok(result.includes("PRIMARY_AGENT_CONTENT"), "should use .github/agents/squad.agent.md (primary) when both files exist");
-    assert.equal(result.includes("FALLBACK_AGENT_CONTENT"), false, "should NOT use root squad.agent.md when .github/agents/squad.agent.md exists");
-});
-// ---------------------------------------------------------------------------
-// 9. Result contains project context block with project root
-// ---------------------------------------------------------------------------
-test("getSquadCoordinatorSystemMessage includes project root path in output", async () => {
-    const charter = await loadCharterModule();
-    const fn = charter.getSquadCoordinatorSystemMessage;
-    const projectRoot = makeProjectDir("with-root-in-output", {
-        githubAgentFile: "# Coordinator",
-        teamMd: "# Team",
-    });
-    const result = await fn(projectRoot);
-    assert.ok(result.includes(projectRoot), `result should include the project root path (${projectRoot}), got: ${result.slice(0, 400)}`);
-});
-//# sourceMappingURL=squad-coordinator-system-message.test.js.map

package/dist/squad/squad-session-routing.test.js

@@ -1,260 +0,0 @@
-/**
- * Phase 4 — Session key derivation and API routing tests
- *
- * Covers:
- *  - encodeProjectRef + decodeProjectRef roundtrip (pure functions inlined)
- *  - projectSessionKey format
- *  - Session key derived from projectPath in POST /api/message
- *  - Explicit sessionKey overrides derived sessionKey
- *  - agent_tasks.session_key is set to originating session
- *
- * Note: encodeProjectRef / decodeProjectRef live in web/src/lib/projectRef.ts
- * and are browser-safe pure functions. They are reimplemented inline here so
- * the server-side test suite can validate the contract without importing
- * frontend code.
- */
-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", `squad-routing-${process.pid}`);
-const chapterhouseHome = join(sandboxRoot, ".chapterhouse");
-const dbPath = join(chapterhouseHome, "chapterhouse.db");
-process.env.CHAPTERHOUSE_HOME = sandboxRoot;
-// ---------------------------------------------------------------------------
-// Pure helper re-implementations (browser-safe, no Node.js imports needed)
-// These mirror what Wash will deliver in web/src/lib/projectRef.ts
-// ---------------------------------------------------------------------------
-/** Encode a project root path to a URL-safe base64url string. */
-function encodeProjectRef(projectRoot) {
-    return Buffer.from(projectRoot, "utf-8").toString("base64url");
-}
-/** Decode a base64url string back to the original project root path. */
-function decodeProjectRef(projectRef) {
-    return Buffer.from(projectRef, "base64url").toString("utf-8");
-}
-/** Build the canonical session key for a project session. */
-function projectSessionKey(normalizedRoot) {
-    return `project:${normalizedRoot}`;
-}
-async function loadDbModule() {
-    return await import(new URL(`../store/db.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
-}
-async function loadContextModule() {
-    return await import(new URL(`./context.js?v=${Date.now()}-${Math.random()}`, import.meta.url).href);
-}
-function resetSandbox() {
-    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
-    rmSync(sandboxRoot, { recursive: true, force: true });
-    mkdirSync(chapterhouseHome, { recursive: true });
-}
-test.beforeEach(() => {
-    resetSandbox();
-});
-test.after(() => {
-    rmSync(sandboxRoot, { recursive: true, force: true });
-});
-// ---------------------------------------------------------------------------
-// 1. encodeProjectRef + decodeProjectRef roundtrip
-// ---------------------------------------------------------------------------
-test("encodeProjectRef + decodeProjectRef roundtrip returns original path", () => {
-    const paths = [
-        "/home/user/myrepo",
-        "/home/alice/projects/chapterhouse",
-        "/var/srv/prod-api",
-        "/some/path with spaces/and-dashes",
-    ];
-    for (const original of paths) {
-        const encoded = encodeProjectRef(original);
-        const decoded = decodeProjectRef(encoded);
-        assert.equal(decoded, original, `roundtrip failed for path: ${original}`);
-    }
-});
-test("encodeProjectRef produces URL-safe output (no +, /, = characters)", () => {
-    const path = "/home/user/some+tricky/path=value";
-    const encoded = encodeProjectRef(path);
-    assert.equal(encoded.includes("+"), false, "encoded ref should not contain +");
-    assert.equal(encoded.includes("/"), false, "encoded ref should not contain /");
-    assert.equal(encoded.includes("="), false, "encoded ref should not contain =");
-});
-// ---------------------------------------------------------------------------
-// 2. projectSessionKey format
-// ---------------------------------------------------------------------------
-test("projectSessionKey produces 'project:<path>' format", () => {
-    const path = "/home/user/repo";
-    const key = projectSessionKey(path);
-    assert.equal(key, "project:/home/user/repo");
-    assert.match(key, /^project:\//, "session key should start with 'project:/'");
-});
-test("projectSessionKey is stable — same input produces same output", () => {
-    const path = "/home/user/consistent-repo";
-    assert.equal(projectSessionKey(path), projectSessionKey(path));
-});
-// ---------------------------------------------------------------------------
-// 3. Session key from projectPath in API message handler
-// ---------------------------------------------------------------------------
-test("POST /api/message request body: sessionKey derived from projectPath uses 'project:' prefix", async () => {
-    // This test validates the _contract_ that the /api/message handler must honour:
-    // when a request arrives with projectPath set, the derived session key must be
-    // project:${normalizeProjectPath(projectPath)}.
-    const context = await loadContextModule();
-    const projectPath = "/home/tester/my-app";
-    const normalized = context.normalizeProjectPath(projectPath);
-    const derived = projectSessionKey(normalized);
-    assert.equal(derived, `project:${normalized}`, "session key derived from projectPath must be project:${normalized}");
-    assert.match(derived, /^project:\//, "derived session key must start with 'project:/'");
-});
-// ---------------------------------------------------------------------------
-// 4. Explicit sessionKey overrides derived key
-// ---------------------------------------------------------------------------
-test("explicit sessionKey in request body overrides projectPath-derived key", () => {
-    // Pure logic test: when both sessionKey and projectPath are present,
-    // sessionKey takes precedence. This mimics the handler contract.
-    function deriveEffectiveSessionKey(opts) {
-        if (opts.sessionKey)
-            return opts.sessionKey;
-        if (opts.projectPath)
-            return projectSessionKey(opts.normalizeProjectPath(opts.projectPath));
-        return "default";
-    }
-    const result = deriveEffectiveSessionKey({
-        sessionKey: "project:/explicit/override",
-        projectPath: "/some/other/path",
-        normalizeProjectPath: (p) => p,
-    });
-    assert.equal(result, "project:/explicit/override", "explicit sessionKey must win over projectPath-derived key");
-});
-test("no sessionKey and no projectPath defaults to 'default' session", () => {
-    function deriveEffectiveSessionKey(opts) {
-        if (opts.sessionKey)
-            return opts.sessionKey;
-        if (opts.projectPath)
-            return projectSessionKey(opts.normalizeProjectPath(opts.projectPath));
-        return "default";
-    }
-    const result = deriveEffectiveSessionKey({
-        normalizeProjectPath: (p) => p,
-    });
-    assert.equal(result, "default", "absence of both sessionKey and projectPath must yield 'default'");
-});
-// ---------------------------------------------------------------------------
-// 5. agent_tasks.session_key — task created in project session stores correct key
-// ---------------------------------------------------------------------------
-test("agent_tasks session_key is persisted and matches the originating session", async () => {
-    const dbModule = await loadDbModule();
-    try {
-        const db = dbModule.getDb();
-        // Verify the column exists
-        const cols = db.prepare(`PRAGMA table_info(agent_tasks)`).all();
-        const colNames = new Set(cols.map((c) => c.name));
-        assert.equal(colNames.has("session_key"), true, "agent_tasks should have session_key column");
-        // Insert a task with a project session key (simulating a delegated task)
-        const sessionKey = "project:/home/tester/repo-x";
-        db.prepare(`
-      INSERT INTO agent_tasks (task_id, agent_slug, description, status, session_key)
-      VALUES (?, ?, ?, ?, ?)
-    `).run("task-001", "coder", "Implement feature X", "running", sessionKey);
-        const row = db.prepare(`SELECT session_key FROM agent_tasks WHERE task_id = 'task-001'`).get();
-        assert.ok(row, "task row should exist");
-        assert.equal(row.session_key, sessionKey, "stored session_key must match the originating session");
-    }
-    finally {
-        dbModule.closeDb();
-    }
-});
-// ---------------------------------------------------------------------------
-// 6. /projects/chat/:projectRef route — decoding produces valid session key
-// ---------------------------------------------------------------------------
-test("decoding :projectRef from route produces valid project session key", () => {
-    const projectRoot = "/home/user/my-project";
-    const projectRef = encodeProjectRef(projectRoot);
-    // Simulate what the frontend router does: decode the param and derive session key
-    const decoded = decodeProjectRef(projectRef);
-    const sessionKey = projectSessionKey(decoded);
-    assert.equal(decoded, projectRoot, "decoded path must match original");
-    assert.equal(sessionKey, `project:${projectRoot}`, "session key must be project:${path}");
-});
-// ---------------------------------------------------------------------------
-// 7. SSE / final message payload includes sessionKey field
-// ---------------------------------------------------------------------------
-test("SSE message payload contract: sessionKey field is present and matches active session", () => {
-    function buildSsePayload(sessionKey, content, projectPath) {
-        const payload = { sessionKey, content };
-        if (projectPath)
-            payload.projectPath = projectPath;
-        return payload;
-    }
-    const defaultPayload = buildSsePayload("default", "Hello from default chat");
-    assert.equal(defaultPayload.sessionKey, "default");
-    assert.equal(defaultPayload.projectPath, undefined);
-    const projectPayload = buildSsePayload("project:/home/user/repo", "Hello from project", "/home/user/repo");
-    assert.equal(projectPayload.sessionKey, "project:/home/user/repo");
-    assert.equal(projectPayload.projectPath, "/home/user/repo");
-});
-// ---------------------------------------------------------------------------
-// 8. copilot_sessions upsert is idempotent (re-upsert updates copilot_session_id)
-// ---------------------------------------------------------------------------
-test("upsertCopilotSession is idempotent — second upsert updates copilot_session_id", async () => {
-    const dbModule = await loadDbModule();
-    try {
-        dbModule.getDb();
-        if (typeof dbModule.upsertCopilotSession !== "function" || typeof dbModule.getCopilotSession !== "function") {
-            // Functions not yet implemented — test will be completed when Mal ships Phase 1
-            return;
-        }
-        const key = "project:/home/user/idempotent-test";
-        dbModule.upsertCopilotSession(key, "project", "session-v1", "/home/user/idempotent-test");
-        dbModule.upsertCopilotSession(key, "project", "session-v2", "/home/user/idempotent-test");
-        const row = dbModule.getCopilotSession(key);
-        assert.ok(row, "row should exist after double upsert");
-        assert.equal(row.copilotSessionId, "session-v2", "second upsert should overwrite copilot_session_id");
-    }
-    finally {
-        dbModule.closeDb();
-    }
-});
-// ---------------------------------------------------------------------------
-// 9. Default session and project session have independent copilot_session_ids
-// ---------------------------------------------------------------------------
-test("default session and project session store independent copilot_session_ids", async () => {
-    const dbModule = await loadDbModule();
-    try {
-        dbModule.getDb();
-        if (typeof dbModule.upsertCopilotSession !== "function" || typeof dbModule.getCopilotSession !== "function") {
-            return; // Not yet implemented
-        }
-        dbModule.upsertCopilotSession("default", "default", "default-sdk-session");
-        dbModule.upsertCopilotSession("project:/home/user/proj-a", "project", "project-a-sdk-session", "/home/user/proj-a");
-        dbModule.upsertCopilotSession("project:/home/user/proj-b", "project", "project-b-sdk-session", "/home/user/proj-b");
-        const defaultRow = dbModule.getCopilotSession("default");
-        const projARow = dbModule.getCopilotSession("project:/home/user/proj-a");
-        const projBRow = dbModule.getCopilotSession("project:/home/user/proj-b");
-        assert.equal(defaultRow?.copilotSessionId, "default-sdk-session");
-        assert.equal(projARow?.copilotSessionId, "project-a-sdk-session");
-        assert.equal(projBRow?.copilotSessionId, "project-b-sdk-session");
-        // All three must be distinct
-        const ids = [defaultRow?.copilotSessionId, projARow?.copilotSessionId, projBRow?.copilotSessionId];
-        assert.equal(new Set(ids).size, 3, "all three sessions must have distinct copilot_session_ids");
-    }
-    finally {
-        dbModule.closeDb();
-    }
-});
-// ---------------------------------------------------------------------------
-// 10. SSE cancelled payload includes sessionKey
-// ---------------------------------------------------------------------------
-test("SSE cancelled payload contract: sessionKey field is present", () => {
-    function buildCancelledPayload(sessionKey) {
-        return { type: "cancelled", sessionKey };
-    }
-    const defaultPayload = buildCancelledPayload("default");
-    assert.equal(defaultPayload.type, "cancelled", "type must be 'cancelled'");
-    assert.equal(defaultPayload.sessionKey, "default", "sessionKey must be present for default session");
-    const projectPayload = buildCancelledPayload("project:/home/user/repo");
-    assert.equal(projectPayload.type, "cancelled");
-    assert.equal(projectPayload.sessionKey, "project:/home/user/repo", "sessionKey must be present and match for project session");
-    assert.ok("sessionKey" in defaultPayload, "sessionKey field must exist on cancelled payload");
-    assert.ok("sessionKey" in projectPayload, "sessionKey field must exist on project cancelled payload");
-});
-//# sourceMappingURL=squad-session-routing.test.js.map

package/dist/squad/types.js

@@ -1,4 +0,0 @@
-// New runtime types for the Squad integration layer.
-// These are pure TypeScript types — no runtime dependencies.
-export {};
-//# sourceMappingURL=types.js.map