@nonbot/cli 0.5.14 → 0.6.0

package/dist/lib/choir/names.js

@@ -0,0 +1,39 @@
+import path from 'node:path';
+import { NAME_RE, BRANCH_RE, PANE_ID_RE } from './types.js';
+export function isValidName(s) {
+    return typeof s === 'string' && NAME_RE.test(s);
+}
+export function isValidBranch(s) {
+    return typeof s === 'string' && BRANCH_RE.test(s);
+}
+export function isValidPaneId(s) {
+    return typeof s === 'string' && PANE_ID_RE.test(s);
+}
+export function assertValidName(s, kind = 'name') {
+    if (!isValidName(s)) {
+        throw new Error(`invalid choir ${kind}: must match ^[a-z0-9][a-z0-9-]{0,30}$`);
+    }
+    return s;
+}
+export function assertValidBranch(s, kind = 'branch') {
+    if (!isValidBranch(s)) {
+        throw new Error(`invalid choir ${kind}: must match ^[a-z0-9][a-z0-9/-]{0,60}$`);
+    }
+    return s;
+}
+export function worktreePathFor(choirRoot, sessionName, paneName) {
+    assertValidName(sessionName, 'session');
+    assertValidName(paneName, 'pane');
+    const box = path.resolve(choirRoot, '.choir/wt');
+    const full = path.join(choirRoot, '.choir/wt', paneName);
+    const resolved = path.resolve(full);
+    if (resolved !== box && !resolved.startsWith(box + path.sep)) {
+        throw new Error('choir worktree path escaped .choir/wt containment');
+    }
+    return full;
+}
+export function branchFor(sessionName, paneName) {
+    assertValidName(sessionName, 'session');
+    assertValidName(paneName, 'pane');
+    return `choir/${sessionName}/${paneName}`;
+}

package/dist/lib/choir/needs-you.js

@@ -0,0 +1,210 @@
+import { SEVERITY_WEIGHT } from './types.js';
+export function itemId(sessionId, paneId, type) {
+    return `${sessionId}::${paneId ?? '_session'}::${type}`;
+}
+function entryType(e) {
+    const reason = e.refs?.blockReason;
+    if (reason === 'agent-crashed' || reason === 'spawn-failed')
+        return 'crashed';
+    if (reason === 'merge-conflict')
+        return 'merge-conflict';
+    if (reason === 'build-failed')
+        return 'build-failed';
+    switch (e.stage) {
+        case 'awaiting-input':
+            return 'awaiting-input';
+        case 'reconcile-blocked':
+            return 'reconcile-blocked';
+        case 'collision-detected':
+            return 'collision';
+        case 'stalled':
+            return 'stalled';
+        case 'monitor-offline':
+            return 'monitor-offline';
+        case 'pane-failed':
+            return 'crashed';
+        default:
+            return null;
+    }
+}
+const PANE_RESUME_STAGES = new Set([
+    'resumed',
+    'working',
+    'agent-started',
+]);
+const PANE_TERMINAL_OK_STAGES = new Set([
+    'pane-complete',
+    'finished',
+    'pane-stopped',
+]);
+export function projectNeedsYou(events, _now) {
+    const live = new Map();
+    const ordered = [...events].sort((a, b) => a.ts - b.ts);
+    for (const e of ordered) {
+        const paneResolves = e.paneId != null &&
+            (PANE_TERMINAL_OK_STAGES.has(e.stage) ||
+                (e.terminal && (e.stage === 'pane-complete' || e.stage === 'finished')));
+        if (paneResolves) {
+            for (const [id, item] of [...live]) {
+                if (item.paneId === e.paneId)
+                    live.delete(id);
+            }
+            continue;
+        }
+        if (PANE_RESUME_STAGES.has(e.stage) && e.paneId != null) {
+            live.delete(itemId(e.sessionId, e.paneId, 'awaiting-input'));
+            live.delete(itemId(e.sessionId, e.paneId, 'stalled'));
+            continue;
+        }
+        if (e.stage === 'collision-cleared') {
+            live.delete(itemId(e.sessionId, e.paneId, 'collision'));
+            continue;
+        }
+        if (e.stage === 'reconcile-complete') {
+            live.delete(itemId(e.sessionId, e.paneId, 'reconcile-blocked'));
+            live.delete(itemId(e.sessionId, e.paneId, 'merge-conflict'));
+            continue;
+        }
+        const type = entryType(e);
+        if (!type)
+            continue;
+        const id = itemId(e.sessionId, e.paneId, type);
+        const existing = live.get(id);
+        if (existing) {
+            existing.severity = e.severity;
+            existing.summary = e.summary;
+            existing.reason = e.refs?.blockReason ?? existing.reason;
+            existing.branch = e.refs?.branch ?? existing.branch;
+        }
+        else {
+            live.set(id, {
+                id,
+                sessionId: e.sessionId,
+                paneId: e.paneId,
+                branch: e.refs?.branch,
+                type,
+                severity: e.severity,
+                reason: e.refs?.blockReason,
+                summary: e.summary,
+                enteredAt: e.ts,
+                dismissed: false,
+            });
+        }
+    }
+    return [...live.values()];
+}
+const HALT_TYPES = new Set(['crashed', 'reconcile-blocked']);
+function ageMin(item, now) {
+    return Math.max(0, (now - item.enteredAt) / 60_000);
+}
+function priority(item, now) {
+    return SEVERITY_WEIGHT[item.severity] * 100 + Math.min(ageMin(item, now), 60);
+}
+export function prioritize(items, now) {
+    return [...items].sort((a, b) => {
+        const aHalt = HALT_TYPES.has(a.type);
+        const bHalt = HALT_TYPES.has(b.type);
+        if (aHalt !== bHalt)
+            return aHalt ? -1 : 1;
+        const pd = priority(b, now) - priority(a, now);
+        if (pd !== 0)
+            return pd;
+        return a.enteredAt - b.enteredAt;
+    });
+}
+export function dismiss(items, id) {
+    return items.map((i) => (i.id === id ? { ...i, dismissed: true } : i));
+}
+const HISTORY_STAGES = new Set([
+    'broadcast-sent',
+    'collision-detected',
+    'collision-cleared',
+    'reconcile-started',
+    'reconcile-complete',
+    'reconcile-blocked',
+    'session-created',
+    'worktrees-provisioned',
+    'panes-spawned',
+    'all-complete',
+    'session-ended',
+    'pane-spawned',
+    'pane-complete',
+    'pane-failed',
+    'pane-stopped',
+    'merge-step',
+    'build-gate',
+    'monitor-offline',
+    'stalled',
+]);
+function isHistoryStage(e) {
+    if (HISTORY_STAGES.has(e.stage))
+        return true;
+    if (e.severity === 'attention-needed' || e.severity === 'blocked' || e.severity === 'error')
+        return true;
+    return e.category === 'lifecycle' || e.category === 'coordination' || e.category === 'reconcile' || e.category === 'verification';
+}
+function paneTally(events) {
+    const lastStatus = new Map();
+    for (const e of [...events].sort((a, b) => a.ts - b.ts)) {
+        if (e.paneId == null)
+            continue;
+        if (PANE_TERMINAL_OK_STAGES.has(e.stage) || (e.terminal && e.stage === 'pane-complete')) {
+            lastStatus.set(e.paneId, 'done');
+        }
+        else if (e.stage === 'pane-failed' || e.stage === 'pane-stopped') {
+            lastStatus.set(e.paneId, 'done');
+        }
+        else {
+            lastStatus.set(e.paneId, 'working');
+        }
+    }
+    let done = 0;
+    let working = 0;
+    for (const v of lastStatus.values())
+        v === 'done' ? done++ : working++;
+    return { done, working };
+}
+function buildSessionNarrative(sessionId, events) {
+    const { done, working } = paneTally(events);
+    const lastTs = events.reduce((m, e) => Math.max(m, e.ts), 0);
+    const parts = [];
+    if (done > 0)
+        parts.push(`${done} pane${done === 1 ? '' : 's'} finished`);
+    if (working > 0)
+        parts.push(`${working} still working`);
+    const blocks = events.filter((e) => e.severity === 'blocked' || e.severity === 'error').length;
+    if (blocks > 0)
+        parts.push(`${blocks} need attention`);
+    const narrative = parts.length ? `${parts.join(', ')}.` : 'No notable activity.';
+    return { sessionId, narrative, lastTs };
+}
+export function buildDigest(events, lastSeenAt, now) {
+    const windowed = events.filter((e) => e.ts > lastSeenAt);
+    const projected = projectNeedsYou(events, now).filter((i) => !i.dismissed);
+    const needsYou = prioritize(projected, now);
+    const bySession = new Map();
+    for (const e of windowed) {
+        const arr = bySession.get(e.sessionId) ?? [];
+        arr.push(e);
+        bySession.set(e.sessionId, arr);
+    }
+    const sessions = [...bySession.entries()]
+        .map(([sid, evs]) => buildSessionNarrative(sid, evs))
+        .sort((a, b) => b.lastTs - a.lastTs);
+    const changes = windowed
+        .filter(isHistoryStage)
+        .sort((a, b) => b.ts - a.ts)
+        .map((e) => ({
+        stage: e.stage,
+        severity: e.severity,
+        paneId: e.paneId,
+        summary: e.summary,
+        ts: e.ts,
+    }));
+    const digest = { sessions, needsYou, changes };
+    if (needsYou.length === 0) {
+        const { done, working } = paneTally(windowed);
+        digest.calmLine = `Nothing needs you. ${done} pane${done === 1 ? '' : 's'} done, ${working} still working.`;
+    }
+    return digest;
+}

package/dist/lib/choir/progress-events.js

@@ -0,0 +1,228 @@
+import { SCHEMA_VERSION, SUMMARY_MAX, EGRESS_ALLOWED_TOP_KEYS, EGRESS_FORBIDDEN_KEYS, BRANCH_RE, } from './types.js';
+const CROCKFORD = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+const TIME_LEN = 10;
+const RAND_LEN = 16;
+function encodeTime(ms) {
+    let t = Math.floor(ms);
+    const out = new Array(TIME_LEN);
+    for (let i = TIME_LEN - 1; i >= 0; i--) {
+        const mod = t % 32;
+        out[i] = CROCKFORD[mod];
+        t = Math.floor(t / 32);
+    }
+    return out.join('');
+}
+function encodeRandom(random) {
+    const out = new Array(RAND_LEN);
+    for (let i = 0; i < RAND_LEN; i++) {
+        out[i] = Math.floor(random() * 32) % 32;
+    }
+    return out;
+}
+function indicesToString(idx) {
+    let s = '';
+    for (const i of idx)
+        s += CROCKFORD[i];
+    return s;
+}
+export function ulid(ms, random = Math.random) {
+    return encodeTime(ms) + indicesToString(encodeRandom(random));
+}
+export function makeUlidFactory(deps) {
+    const random = deps.random ?? Math.random;
+    let lastMs = -1;
+    let lastRand = [];
+    return function next() {
+        const ms = Math.floor(deps.now());
+        if (ms === lastMs) {
+            lastRand = incrementBase32(lastRand);
+        }
+        else {
+            lastMs = ms;
+            lastRand = encodeRandom(random);
+        }
+        return encodeTime(ms) + indicesToString(lastRand);
+    };
+}
+function incrementBase32(idx) {
+    const out = idx.slice();
+    for (let i = out.length - 1; i >= 0; i--) {
+        if (out[i] < 31) {
+            out[i] += 1;
+            return out;
+        }
+        out[i] = 0;
+    }
+    return out;
+}
+const STAGE_TABLE = {
+    queued: { category: 'lifecycle', severity: 'info', terminal: false },
+    accepted: { category: 'lifecycle', severity: 'info', terminal: false },
+    launching: { category: 'provisioning', severity: 'progress', terminal: false },
+    'agent-started': { category: 'lifecycle', severity: 'progress', terminal: false },
+    working: { category: 'work', severity: 'progress', terminal: false },
+    'awaiting-input': { category: 'work', severity: 'blocked', terminal: false },
+    resumed: { category: 'work', severity: 'progress', terminal: false },
+    finished: { category: 'lifecycle', severity: 'info', terminal: true },
+    failed: { category: 'fault', severity: 'error', terminal: true },
+    stopped: { category: 'control', severity: 'info', terminal: true },
+    'session-created': { category: 'lifecycle', severity: 'info', terminal: false },
+    'worktrees-provisioned': { category: 'provisioning', severity: 'progress', terminal: false },
+    'panes-spawned': { category: 'provisioning', severity: 'progress', terminal: false },
+    'collision-detected': { category: 'coordination', severity: 'attention-needed', terminal: false },
+    'collision-cleared': { category: 'coordination', severity: 'progress', terminal: false },
+    'all-complete': { category: 'lifecycle', severity: 'attention-needed', terminal: false },
+    'reconcile-started': { category: 'reconcile', severity: 'progress', terminal: false },
+    'reconcile-complete': { category: 'reconcile', severity: 'info', terminal: true },
+    'reconcile-blocked': { category: 'reconcile', severity: 'blocked', terminal: true },
+    'session-ended': { category: 'lifecycle', severity: 'info', terminal: true },
+    'pane-spawned': { category: 'provisioning', severity: 'progress', terminal: false },
+    'claim-announced': { category: 'coordination', severity: 'progress', terminal: false },
+    'broadcast-sent': { category: 'coordination', severity: 'attention-needed', terminal: false },
+    'pane-complete': { category: 'work', severity: 'progress', terminal: true },
+    'pane-failed': { category: 'fault', severity: 'error', terminal: true },
+    'pane-stopped': { category: 'control', severity: 'info', terminal: true },
+    'merge-step': { category: 'reconcile', severity: 'progress', terminal: false },
+    'build-gate': { category: 'verification', severity: 'progress', terminal: false },
+    slow: { category: 'fault', severity: 'attention-needed', terminal: false },
+    stalled: { category: 'fault', severity: 'attention-needed', terminal: false },
+    'monitor-offline': { category: 'fault', severity: 'error', terminal: false },
+};
+const UNKNOWN_STAGE_META = {
+    category: 'work',
+    severity: 'progress',
+    terminal: false,
+};
+export function stageMapping(stage) {
+    return STAGE_TABLE[stage] ?? UNKNOWN_STAGE_META;
+}
+function clampStr(s, max = SUMMARY_MAX) {
+    if (typeof s !== 'string')
+        return '';
+    return s.slice(0, max);
+}
+export function makeEvent(input, deps) {
+    const meta = stageMapping(input.stage);
+    const eventId = ulid(Math.floor(deps.now()), deps.random);
+    const event = {
+        schemaVersion: SCHEMA_VERSION,
+        eventId,
+        sessionId: clampStr(input.sessionId),
+        engine: input.engine,
+        paneId: input.paneId ?? null,
+        parentEventId: input.parentEventId ?? null,
+        stage: input.stage,
+        category: meta.category,
+        severity: meta.severity,
+        terminal: meta.terminal,
+        summary: clampStr(input.summary),
+        ts: Math.floor(input.ts),
+    };
+    if (input.metrics) {
+        event.metrics = sanitizeMetrics(input.metrics);
+    }
+    if (input.refs) {
+        event.refs = sanitizeRefs(input.refs);
+    }
+    return event;
+}
+const FORBIDDEN_KEY_SET = new Set(EGRESS_FORBIDDEN_KEYS);
+const ALLOWED_TOP_SET = new Set(EGRESS_ALLOWED_TOP_KEYS);
+function isForbiddenKey(key) {
+    return FORBIDDEN_KEY_SET.has(key);
+}
+function sanitizeMetrics(m) {
+    const out = {};
+    if (m && typeof m === 'object') {
+        for (const [k, v] of Object.entries(m)) {
+            if (isForbiddenKey(k))
+                continue;
+            if (typeof v === 'number' && Number.isFinite(v))
+                out[k] = v;
+        }
+    }
+    return out;
+}
+function sanitizeRefs(r) {
+    return deepClean(r);
+}
+function deepClean(value) {
+    if (typeof value === 'string')
+        return value.slice(0, SUMMARY_MAX);
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? value : null;
+    if (typeof value === 'boolean' || value === null)
+        return value;
+    if (Array.isArray(value))
+        return value.map((v) => deepClean(v));
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            if (isForbiddenKey(k))
+                continue;
+            out[k] = deepClean(v);
+        }
+        return out;
+    }
+    return null;
+}
+export function sanitizeForEgress(obj) {
+    const out = {};
+    if (!obj || typeof obj !== 'object')
+        return out;
+    for (const [k, v] of Object.entries(obj)) {
+        if (!ALLOWED_TOP_SET.has(k))
+            continue;
+        if (isForbiddenKey(k))
+            continue;
+        if (k === 'metrics') {
+            out[k] = sanitizeMetrics(v);
+            continue;
+        }
+        out[k] = deepClean(v);
+    }
+    return out;
+}
+const SECRET_RE = /\b(pat_[A-Za-z0-9_-]{4,}|sk_[A-Za-z0-9_-]{4,})/;
+const DIFF_RE = /^(diff --git |@@ |[+-]{3} )|(\n[+-])/;
+const PATH_RE = /(^|[\s'"])\/[\w.-]+\/[\w./-]+/;
+function looksLikePath(s) {
+    return PATH_RE.test(s);
+}
+function looksLikeDiff(s) {
+    return DIFF_RE.test(s);
+}
+function looksLikeSecret(s) {
+    return SECRET_RE.test(s);
+}
+export function assertNoForbiddenFields(payload, keyPath = '$') {
+    walk(payload, keyPath, false);
+}
+function walk(value, keyPath, parentIsBranch) {
+    if (typeof value === 'string') {
+        if (parentIsBranch && BRANCH_RE.test(value))
+            return;
+        if (looksLikeSecret(value)) {
+            throw new Error(`assertNoForbiddenFields: secret-like value at ${keyPath}`);
+        }
+        if (looksLikeDiff(value)) {
+            throw new Error(`assertNoForbiddenFields: diff-like value at ${keyPath}`);
+        }
+        if (looksLikePath(value)) {
+            throw new Error(`assertNoForbiddenFields: path-like value at ${keyPath}`);
+        }
+        return;
+    }
+    if (Array.isArray(value)) {
+        value.forEach((v, i) => walk(v, `${keyPath}[${i}]`, false));
+        return;
+    }
+    if (value && typeof value === 'object') {
+        for (const [k, v] of Object.entries(value)) {
+            if (isForbiddenKey(k)) {
+                throw new Error(`assertNoForbiddenFields: forbidden key '${k}' at ${keyPath}.${k}`);
+            }
+            walk(v, `${keyPath}.${k}`, k === 'branch');
+        }
+    }
+}