chapterhouse 0.3.13 → 0.3.15

package/dist/squad/init.test.js

@@ -1,351 +0,0 @@
-/**
- * src/squad/init.test.ts
- *
- * Tests for the Squad init scaffolding module.
- *
- * Coverage:
- * - scaffoldSquad produces the expected .squad/ layout
- * - isSquadInitialized correctly detects initialized/uninitialized dirs
- * - Idempotence: scaffoldSquad returns null (does not clobber) on re-run
- * - Dune universe character allocation
- * - allocateCast uses the selected universe
- * - resolveRoles clamps to valid presets
- * - force flag overrides idempotence guard
- */
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, readFileSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir as osTmpdir } from 'node:os';
-import test from 'node:test';
-import { scaffoldSquad, isSquadInitialized, allocateCast, resolveRoles, DUNE_CHARACTERS, UNIVERSE_CHARACTERS, DEFAULT_UNIVERSE, } from './init.js';
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function makeTempDir() {
-    return mkdtempSync(join(osTmpdir(), 'ch-init-test-'));
-}
-function cleanup(dir) {
-    rmSync(dir, { recursive: true, force: true });
-}
-// ---------------------------------------------------------------------------
-// Unit tests — pure functions
-// ---------------------------------------------------------------------------
-test('DUNE_CHARACTERS has at least 5 entries', () => {
-    assert.ok(DUNE_CHARACTERS.length >= 5, `Expected ≥ 5 Dune characters, got ${DUNE_CHARACTERS.length}`);
-});
-test('UNIVERSE_CHARACTERS includes Dune', () => {
-    assert.ok('Dune' in UNIVERSE_CHARACTERS, 'UNIVERSE_CHARACTERS must include "Dune"');
-    assert.equal(UNIVERSE_CHARACTERS['Dune'], DUNE_CHARACTERS);
-});
-test('DEFAULT_UNIVERSE is Dune', () => {
-    assert.equal(DEFAULT_UNIVERSE, 'Dune');
-});
-test('resolveRoles(4) returns 4 roles', () => {
-    const roles = resolveRoles(4);
-    assert.equal(roles.length, 4);
-});
-test('resolveRoles(3) returns 3 roles', () => {
-    assert.equal(resolveRoles(3).length, 3);
-});
-test('resolveRoles(5) returns 5 roles', () => {
-    assert.equal(resolveRoles(5).length, 5);
-});
-test('resolveRoles clamps values below 3 to 3', () => {
-    assert.equal(resolveRoles(1).length, 3);
-});
-test('resolveRoles clamps values above 5 to 5', () => {
-    assert.equal(resolveRoles(10).length, 5);
-});
-test('allocateCast assigns Dune names in order', () => {
-    const roles = resolveRoles(4);
-    const cast = allocateCast(roles, 'Dune');
-    assert.equal(Object.keys(cast).length, 4);
-    // First role maps to first Dune character
-    const firstRoleSlug = roles[0].slug;
-    assert.equal(cast[firstRoleSlug], DUNE_CHARACTERS[0]);
-});
-test('allocateCast uses provided universe', () => {
-    const roles = resolveRoles(3);
-    const cast = allocateCast(roles, 'Firefly');
-    const firfly = UNIVERSE_CHARACTERS['Firefly'];
-    const firstRoleSlug = roles[0].slug;
-    assert.equal(cast[firstRoleSlug], firfly[0]);
-});
-test('allocateCast falls back to Dune for unknown universe', () => {
-    const roles = resolveRoles(3);
-    const cast = allocateCast(roles, 'UnknownUniverse');
-    const firstRoleSlug = roles[0].slug;
-    assert.equal(cast[firstRoleSlug], DUNE_CHARACTERS[0]);
-});
-// ---------------------------------------------------------------------------
-// isSquadInitialized
-// ---------------------------------------------------------------------------
-test('isSquadInitialized returns false for empty dir', () => {
-    const dir = makeTempDir();
-    try {
-        assert.equal(isSquadInitialized(dir), false);
-    }
-    finally {
-        cleanup(dir);
-    }
-});
-test('isSquadInitialized returns false when team.md missing', () => {
-    const dir = makeTempDir();
-    try {
-        assert.equal(isSquadInitialized(dir), false);
-    }
-    finally {
-        cleanup(dir);
-    }
-});
-// ---------------------------------------------------------------------------
-// scaffoldSquad integration
-// ---------------------------------------------------------------------------
-const BASE_CONFIG = {
-    projectName: 'TestApp',
-    stack: 'TypeScript, Node.js',
-    goal: 'A test application',
-    teamSize: 4,
-    universe: 'Dune',
-    humanName: 'Alice',
-};
-test('scaffoldSquad returns ScaffoldResult with 4 cast agents', () => {
-    const dir = makeTempDir();
-    try {
-        const result = scaffoldSquad(dir, BASE_CONFIG);
-        assert.ok(result !== null, 'scaffoldSquad should return a result');
-        assert.equal(result.agents.length, 4, 'Should cast 4 agents');
-        assert.equal(result.universe, 'Dune');
-    }
-    finally {
-        cleanup(dir);
-    }
-});
-test('scaffoldSquad creates .squad directory', () => {
-    const dir = makeTempDir();
-    try {
-        scaffoldSquad(dir, BASE_CONFIG);
-        assert.ok(existsSync(join(dir, '.squad')), '.squad/ must exist');
-    }
-    finally {
-        cleanup(dir);
-    }
-});
-test('scaffoldSquad creates team.md with ## Members section', () => {
-    const dir = makeTempDir();
-    try {
-        scaffoldSquad(dir, BASE_CONFIG);
-        const teamMd = readFileSync(join(dir, '.squad', 'team.md'), 'utf-8');
-        assert.ok(teamMd.includes('## Members'), 'team.md must contain ## Members');
-        assert.ok(teamMd.includes('Scribe'), 'team.md must list Scribe');
-        assert.ok(teamMd.includes('Ralph'), 'team.md must list Ralph');
-    }
-    finally {
-        cleanup(dir);
-    }
-});
-test('scaffoldSquad creates team.md with project info', () => {
-    const dir = makeTempDir();
-    try {
-        scaffoldSquad(dir, BASE_CONFIG);
-        const teamMd = readFileSync(join(dir, '.squad', 'team.md'), 'utf-8');
-        assert.ok(teamMd.includes('TestApp'), 'team.md must contain project name');
-        assert.ok(teamMd.includes('Dune'), 'team.md must contain universe');
-        assert.ok(teamMd.includes('Alice'), 'team.md must contain human name');
-    }
-    finally {
-        cleanup(dir);
-    }
-});
-test('scaffoldSquad creates routing.md', () => {
-    const dir = makeTempDir();
-    try {
-        scaffoldSquad(dir, BASE_CONFIG);
-        assert.ok(existsSync(join(dir, '.squad', 'routing.md')));
-    }
-    finally {
-        cleanup(dir);
-    }
-});
-test('scaffoldSquad creates ceremonies.md', () => {
-    const dir = makeTempDir();
-    try {
-        scaffoldSquad(dir, BASE_CONFIG);
-        assert.ok(existsSync(join(dir, '.squad', 'ceremonies.md')));
-    }
-    finally {
-        cleanup(dir);
-    }
-});
-test('scaffoldSquad creates decisions.md', () => {
-    const dir = makeTempDir();
-    try {
-        scaffoldSquad(dir, BASE_CONFIG);
-        assert.ok(existsSync(join(dir, '.squad', 'decisions.md')));
-    }
-    finally {
-        cleanup(dir);
-    }
-});
-test('scaffoldSquad creates agent charter.md for each cast agent', () => {
-    const dir = makeTempDir();
-    try {
-        const result = scaffoldSquad(dir, BASE_CONFIG);
-        for (const agent of result.agents) {
-            const charterPath = join(dir, '.squad', 'agents', agent.slug, 'charter.md');
-            assert.ok(existsSync(charterPath), `charter.md missing for ${agent.slug}`);
-            const content = readFileSync(charterPath, 'utf-8');
-            assert.ok(content.includes(agent.castName), `charter should mention ${agent.castName}`);
-        }
-    }
-    finally {
-        cleanup(dir);
-    }
-});
-test('scaffoldSquad creates agent history.md for each cast agent', () => {
-    const dir = makeTempDir();
-    try {
-        const result = scaffoldSquad(dir, BASE_CONFIG);
-        for (const agent of result.agents) {
-            const histPath = join(dir, '.squad', 'agents', agent.slug, 'history.md');
-            assert.ok(existsSync(histPath), `history.md missing for ${agent.slug}`);
-        }
-    }
-    finally {
-        cleanup(dir);
-    }
-});
-test('scaffoldSquad creates scribe and ralph agent dirs', () => {
-    const dir = makeTempDir();
-    try {
-        scaffoldSquad(dir, BASE_CONFIG);
-        assert.ok(existsSync(join(dir, '.squad', 'agents', 'scribe', 'charter.md')));
-        assert.ok(existsSync(join(dir, '.squad', 'agents', 'ralph', 'charter.md')));
-    }
-    finally {
-        cleanup(dir);
-    }
-});
-test('scaffoldSquad creates casting/policy.json', () => {
-    const dir = makeTempDir();
-    try {
-        scaffoldSquad(dir, BASE_CONFIG);
-        const policyPath = join(dir, '.squad', 'casting', 'policy.json');
-        assert.ok(existsSync(policyPath));
-        const policy = JSON.parse(readFileSync(policyPath, 'utf-8'));
-        assert.ok(Array.isArray(policy.allowlist_universes));
-        assert.ok(policy.allowlist_universes.includes('Dune'));
-    }
-    finally {
-        cleanup(dir);
-    }
-});
-test('scaffoldSquad creates casting/registry.json with all agents', () => {
-    const dir = makeTempDir();
-    try {
-        scaffoldSquad(dir, BASE_CONFIG);
-        const reg = JSON.parse(readFileSync(join(dir, '.squad', 'casting', 'registry.json'), 'utf-8'));
-        assert.ok(reg.agents, 'registry must have agents key');
-        assert.ok('scribe' in reg.agents, 'scribe must be in registry');
-        assert.ok('ralph' in reg.agents, 'ralph must be in registry');
-    }
-    finally {
-        cleanup(dir);
-    }
-});
-test('scaffoldSquad creates casting/history.json with assignment snapshot', () => {
-    const dir = makeTempDir();
-    try {
-        const result = scaffoldSquad(dir, BASE_CONFIG);
-        const hist = JSON.parse(readFileSync(join(dir, '.squad', 'casting', 'history.json'), 'utf-8'));
-        assert.ok(Array.isArray(hist.universe_usage_history));
-        assert.equal(hist.universe_usage_history[0].universe, 'Dune');
-        assert.ok(result.assignmentId in hist.assignment_cast_snapshots);
-    }
-    finally {
-        cleanup(dir);
-    }
-});
-test('scaffoldSquad creates or updates .gitattributes', () => {
-    const dir = makeTempDir();
-    try {
-        scaffoldSquad(dir, BASE_CONFIG);
-        const ga = readFileSync(join(dir, '.gitattributes'), 'utf-8');
-        assert.ok(ga.includes('.squad/decisions.md merge=union'), '.gitattributes must include union merge for decisions.md');
-        assert.ok(ga.includes('.squad/agents/*/history.md merge=union'));
-    }
-    finally {
-        cleanup(dir);
-    }
-});
-test('scaffoldSquad is idempotent — returns null on second call', () => {
-    const dir = makeTempDir();
-    try {
-        const first = scaffoldSquad(dir, BASE_CONFIG);
-        assert.ok(first !== null, 'first call should succeed');
-        const second = scaffoldSquad(dir, BASE_CONFIG);
-        assert.equal(second, null, 'second call should return null (idempotent)');
-    }
-    finally {
-        cleanup(dir);
-    }
-});
-test('scaffoldSquad with force:true overwrites existing scaffold', () => {
-    const dir = makeTempDir();
-    try {
-        scaffoldSquad(dir, BASE_CONFIG);
-        const result = scaffoldSquad(dir, { ...BASE_CONFIG, projectName: 'Updated' }, { force: true });
-        assert.ok(result !== null, 'forced call should succeed');
-        const teamMd = readFileSync(join(dir, '.squad', 'team.md'), 'utf-8');
-        assert.ok(teamMd.includes('Updated'), 'team.md should reflect updated project name');
-    }
-    finally {
-        cleanup(dir);
-    }
-});
-test('isSquadInitialized returns true after scaffoldSquad', () => {
-    const dir = makeTempDir();
-    try {
-        scaffoldSquad(dir, BASE_CONFIG);
-        assert.equal(isSquadInitialized(dir), true);
-    }
-    finally {
-        cleanup(dir);
-    }
-});
-test('scaffoldSquad uses Dune names from the canonical pool', () => {
-    const dir = makeTempDir();
-    try {
-        const result = scaffoldSquad(dir, BASE_CONFIG);
-        for (const agent of result.agents) {
-            assert.ok(DUNE_CHARACTERS.includes(agent.castName), `${agent.castName} is not in the Dune character pool`);
-        }
-    }
-    finally {
-        cleanup(dir);
-    }
-});
-test('scaffoldSquad uses Firefly names when universe is Firefly', () => {
-    const dir = makeTempDir();
-    try {
-        const result = scaffoldSquad(dir, { ...BASE_CONFIG, universe: 'Firefly' });
-        const fireflyPool = UNIVERSE_CHARACTERS['Firefly'];
-        for (const agent of result.agents) {
-            assert.ok(fireflyPool.includes(agent.castName), `${agent.castName} is not in the Firefly pool`);
-        }
-    }
-    finally {
-        cleanup(dir);
-    }
-});
-test('scaffoldSquad creates decisions/inbox directory', () => {
-    const dir = makeTempDir();
-    try {
-        scaffoldSquad(dir, BASE_CONFIG);
-        assert.ok(existsSync(join(dir, '.squad', 'decisions', 'inbox')));
-    }
-    finally {
-        cleanup(dir);
-    }
-});
-//# sourceMappingURL=init.test.js.map

package/dist/squad/mirror.js

@@ -1,83 +0,0 @@
-import { basename, join } from 'path';
-import { existsSync, readFileSync, readdirSync } from 'fs';
-import { readPage, writePage } from '../wiki/fs.js';
-import { ensureWikiStructure } from '../wiki/fs.js';
-import { childLogger } from '../util/logger.js';
-const log = childLogger('squad.mirror');
-/**
- * Returns the wiki-relative path for a project's squad decisions page.
- * e.g. "pages/projects/chapterhouse/decisions.md"
- */
-export function projectDecisionWikiPath(projectRoot) {
-    const slug = basename(projectRoot).toLowerCase().replace(/[^a-z0-9-]/g, '-');
-    return `pages/projects/${slug}/decisions.md`;
-}
-/**
- * Append a decision entry to the project's wiki decisions page.
- * Returns the wiki page path that was written.
- *
- * Only call this on successful task completion — the caller is responsible for
- * not invoking on failure.
- */
-export async function mirrorDecisionToWiki(link, taskSummary, resultSummary) {
-    ensureWikiStructure();
-    const wikiPath = projectDecisionWikiPath(link.projectRoot);
-    const dateStr = new Date().toISOString().slice(0, 10);
-    const existing = readPage(wikiPath) ?? `# Squad Decisions — ${basename(link.projectRoot)}\n\n`;
-    const entry = `## ${dateStr}\n- **Agent:** @${link.squadAgentSlug} | **Task:** ${taskSummary} | **Result:** ${resultSummary}\n`;
-    // Append entry, ensuring a blank line separator
-    const separator = existing.endsWith('\n\n') ? '' : existing.endsWith('\n') ? '\n' : '\n\n';
-    const updated = existing + separator + entry;
-    writePage(wikiPath, updated);
-    return wikiPath;
-}
-/**
- * Check the decisions inbox for unmerged decision drops.
- * Returns count and filenames — never throws.
- */
-export async function checkDecisionsInbox(projectRoot) {
-    const inboxPath = join(projectRoot, '.squad', 'decisions', 'inbox');
-    try {
-        if (!existsSync(inboxPath))
-            return { count: 0, files: [] };
-        const files = readdirSync(inboxPath).filter(f => f.endsWith('.md'));
-        return { count: files.length, files };
-    }
-    catch {
-        return { count: 0, files: [] };
-    }
-}
-/**
- * Sync the content of <projectRoot>/.squad/decisions.md verbatim to the
- * project's wiki decisions page.  decisions.md is the source of truth — the
- * wiki page is overwritten on every call.
- *
- * Returns null when decisions.md does not exist (project may not be squad-
- * initialized); never throws — errors are logged and the caller is unaffected.
- */
-export async function syncDecisionsFileToWiki(projectRoot) {
-    const decisionsPath = join(projectRoot, '.squad', 'decisions.md');
-    try {
-        if (!existsSync(decisionsPath))
-            return null;
-        const source = readFileSync(decisionsPath, 'utf-8');
-        ensureWikiStructure();
-        const wikiPath = projectDecisionWikiPath(projectRoot);
-        const timestamp = new Date().toISOString();
-        const header = `<!-- Last synced: ${timestamp} -->\n\n`;
-        writePage(wikiPath, header + source);
-        // Count entries as second-level headings (## …) in the decisions file
-        const entriesSynced = (source.match(/^##\s/gm) ?? []).length;
-        // Visibility check: warn if inbox has unmerged drops
-        const inbox = await checkDecisionsInbox(projectRoot);
-        if (inbox.count > 0) {
-            log.warn({ projectRoot, count: inbox.count, files: inbox.files }, 'unmerged decision drops in inbox — run Scribe to merge');
-        }
-        return { entriesSynced, wikiPath };
-    }
-    catch (err) {
-        log.error({ err: err instanceof Error ? err.message : err }, 'syncDecisionsFileToWiki failed (non-fatal)');
-        return null;
-    }
-}
-//# sourceMappingURL=mirror.js.map

package/dist/squad/mirror.scheduler.js

@@ -1,80 +0,0 @@
-import { getDb } from '../store/db.js';
-import { syncDecisionsFileToWiki } from './mirror.js';
-import { childLogger } from '../util/logger.js';
-const log = childLogger('squad.mirror-scheduler');
-export const DEFAULT_DECISIONS_SYNC_INTERVAL_MS = 300_000; // 5 minutes
-function readIntervalFromEnv() {
-    const raw = process.env.CHAPTERHOUSE_DECISIONS_SYNC_INTERVAL_MS;
-    if (raw === undefined)
-        return DEFAULT_DECISIONS_SYNC_INTERVAL_MS;
-    const parsed = Number(raw);
-    return isNaN(parsed) ? DEFAULT_DECISIONS_SYNC_INTERVAL_MS : parsed;
-}
-function defaultGetRegisteredProjectRoots() {
-    try {
-        const db = getDb();
-        const rows = db
-            .prepare(`SELECT project_root FROM project_squads WHERE registered = 1`)
-            .all();
-        return rows.map(r => r.project_root);
-    }
-    catch (err) {
-        log.error({ err: err instanceof Error ? err.message : err }, 'failed to query registered projects (non-fatal)');
-        return [];
-    }
-}
-export class DecisionsSyncScheduler {
-    intervalMs;
-    getRegisteredProjectRoots;
-    syncFn;
-    setIntervalImpl;
-    clearIntervalImpl;
-    handle;
-    constructor(options = {}) {
-        this.intervalMs = options.intervalMs ?? readIntervalFromEnv();
-        this.getRegisteredProjectRoots = options.getRegisteredProjectRoots ?? defaultGetRegisteredProjectRoots;
-        this.syncFn = options.syncFn ?? syncDecisionsFileToWiki;
-        this.setIntervalImpl = options.setIntervalImpl ?? setInterval;
-        this.clearIntervalImpl = options.clearIntervalImpl ?? clearInterval;
-    }
-    /** Start the periodic sync. No-op if intervalMs <= 0. */
-    start() {
-        if (this.intervalMs <= 0) {
-            log.debug({ intervalMs: this.intervalMs }, 'disabled (intervalMs <= 0)');
-            return;
-        }
-        if (this.handle !== undefined)
-            return; // already running
-        log.info({ intervalMs: this.intervalMs }, 'starting');
-        this.handle = this.setIntervalImpl(() => { void this.tick(); }, this.intervalMs);
-        // Allow Node.js to exit even if the interval is still active
-        this.handle?.unref?.();
-    }
-    /** Stop the periodic sync and clear the timer. */
-    stop() {
-        if (this.handle !== undefined) {
-            this.clearIntervalImpl(this.handle);
-            this.handle = undefined;
-            log.info('stopped');
-        }
-    }
-    async tick() {
-        const projects = this.getRegisteredProjectRoots();
-        if (projects.length === 0)
-            return;
-        log.debug({ projects: projects.length }, 'syncing');
-        for (const root of projects) {
-            try {
-                const result = await this.syncFn(root);
-                if (result) {
-                    log.debug({ entriesSynced: result.entriesSynced, root }, 'synced');
-                }
-            }
-            catch (err) {
-                // syncDecisionsFileToWiki already swallows errors; belt-and-suspenders here
-                log.error({ root, err: err instanceof Error ? err.message : err }, 'unexpected sync error (non-fatal)');
-            }
-        }
-    }
-}
-//# sourceMappingURL=mirror.scheduler.js.map