@nonbot/cli 0.5.15 → 0.6.0

package/dist/lib/choir/reconcile.js

@@ -0,0 +1,271 @@
+import { spawnSync as nodeSpawnSync } from 'node:child_process';
+import { assertValidBranch } from './names.js';
+import { makeEvent } from './progress-events.js';
+export function planMergeOrder(branches, baseBranch) {
+    assertValidBranch(baseBranch, 'base branch');
+    for (const b of branches)
+        assertValidBranch(b, 'branch');
+    const seen = new Set();
+    const out = [];
+    for (const b of branches) {
+        if (b === baseBranch)
+            continue;
+        if (seen.has(b))
+            continue;
+        seen.add(b);
+        out.push(b);
+    }
+    out.sort();
+    return out;
+}
+export function tokenizeGateCommand(cmd) {
+    const tokens = [];
+    let cur = '';
+    let inSingle = false;
+    let inDouble = false;
+    let started = false;
+    for (let i = 0; i < cmd.length; i++) {
+        const ch = cmd[i];
+        if (inSingle) {
+            if (ch === "'")
+                inSingle = false;
+            else
+                cur += ch;
+            continue;
+        }
+        if (inDouble) {
+            if (ch === '"')
+                inDouble = false;
+            else
+                cur += ch;
+            continue;
+        }
+        if (ch === "'") {
+            inSingle = true;
+            started = true;
+            continue;
+        }
+        if (ch === '"') {
+            inDouble = true;
+            started = true;
+            continue;
+        }
+        if (ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r') {
+            if (cur.length > 0 || started) {
+                tokens.push(cur);
+                cur = '';
+                started = false;
+            }
+            continue;
+        }
+        cur += ch;
+        started = true;
+    }
+    if (cur.length > 0 || started)
+        tokens.push(cur);
+    return tokens;
+}
+function runGit(spawnImpl, repoRoot, args) {
+    return spawnImpl('git', ['-C', repoRoot, ...args], {
+        encoding: 'utf-8',
+        timeout: 60_000,
+        windowsHide: true,
+    });
+}
+function countConflictFiles(stdout) {
+    let n = 0;
+    for (const line of stdout.split('\n')) {
+        if (/^CONFLICT\b/.test(line.trim()))
+            n += 1;
+    }
+    return n;
+}
+export function runReconcile(args) {
+    const { repoRoot, baseBranch, buildTestCommand, sessionId = 'choir', spawnImpl = nodeSpawnSync, emit = () => { }, now = () => Date.now(), random, } = args;
+    const order = planMergeOrder(args.branches, baseBranch);
+    const evDeps = { now, random };
+    const ts = () => Math.floor(now());
+    const total = order.length;
+    const startEvent = makeEvent({
+        sessionId,
+        engine: 'choir',
+        paneId: null,
+        stage: 'reconcile-started',
+        summary: `Reconciling ${total} branch${total === 1 ? '' : 'es'} into ${baseBranch}`,
+        ts: ts(),
+        refs: { branch: baseBranch },
+        metrics: { paneTotal: total },
+    }, evDeps);
+    emit(startEvent);
+    const parentEventId = startEvent.eventId;
+    const gateTokens = buildTestCommand.trim() ? tokenizeGateCommand(buildTestCommand) : [];
+    const merged = [];
+    for (let i = 0; i < order.length; i++) {
+        const branch = order[i];
+        const r = runGit(spawnImpl, repoRoot, ['merge', '--no-ff', branch]);
+        const stdout = typeof r.stdout === 'string' ? r.stdout : '';
+        const conflictFiles = countConflictFiles(stdout);
+        const isConflict = r.status !== 0 && (conflictFiles > 0 || /^CONFLICT\b/m.test(stdout));
+        if (isConflict) {
+            runGit(spawnImpl, repoRoot, ['merge', '--abort']);
+            emitBlockedMergeStep(emit, evDeps, {
+                sessionId,
+                parentEventId,
+                branch,
+                baseBranch,
+                conflictFiles,
+                index: i + 1,
+                total,
+                ts: ts(),
+            });
+            emit(blockedEvent(evDeps, {
+                sessionId,
+                parentEventId,
+                branch,
+                baseBranch,
+                reason: 'merge-conflict',
+                conflictFiles,
+                merged: merged.length,
+                total,
+                ts: ts(),
+            }));
+            return { blocked: true, merged, conflictedBranch: branch, reason: 'merge-conflict' };
+        }
+        if (r.status !== 0) {
+            runGit(spawnImpl, repoRoot, ['merge', '--abort']);
+            emit(blockedEvent(evDeps, {
+                sessionId,
+                parentEventId,
+                branch,
+                baseBranch,
+                reason: 'merge-error',
+                merged: merged.length,
+                total,
+                ts: ts(),
+            }));
+            return { blocked: true, merged, erroredBranch: branch, reason: 'merge-error' };
+        }
+        emit(makeEvent({
+            sessionId,
+            engine: 'choir',
+            paneId: null,
+            parentEventId,
+            stage: 'merge-step',
+            summary: `Merged ${branch} into ${baseBranch}`,
+            ts: ts(),
+            refs: { branch },
+            metrics: { storyIndex: i + 1, storyTotal: total, panesComplete: merged.length + 1 },
+        }, evDeps));
+        if (gateTokens.length > 0) {
+            const [gateCmd, ...gateArgs] = gateTokens;
+            const g = spawnImpl(gateCmd, gateArgs, {
+                cwd: repoRoot,
+                encoding: 'utf-8',
+                timeout: 600_000,
+                windowsHide: true,
+            });
+            if (g.status !== 0) {
+                emit(gateEvent(evDeps, {
+                    sessionId,
+                    parentEventId,
+                    branch,
+                    pass: false,
+                    exitCode: typeof g.status === 'number' ? g.status : 1,
+                    index: i + 1,
+                    total,
+                    ts: ts(),
+                }));
+                emit(blockedEvent(evDeps, {
+                    sessionId,
+                    parentEventId,
+                    branch,
+                    baseBranch,
+                    reason: 'build-failed',
+                    merged: merged.length,
+                    total,
+                    ts: ts(),
+                }));
+                return { blocked: true, merged, gateFailedAfter: branch, reason: 'build-failed' };
+            }
+            emit(gateEvent(evDeps, {
+                sessionId,
+                parentEventId,
+                branch,
+                pass: true,
+                exitCode: 0,
+                index: i + 1,
+                total,
+                ts: ts(),
+            }));
+        }
+        merged.push(branch);
+    }
+    emit(makeEvent({
+        sessionId,
+        engine: 'choir',
+        paneId: null,
+        parentEventId,
+        stage: 'reconcile-complete',
+        summary: `Reconciled ${merged.length} branch${merged.length === 1 ? '' : 'es'} into ${baseBranch}, build green`,
+        ts: ts(),
+        refs: { branch: baseBranch },
+        metrics: { paneTotal: total, panesComplete: merged.length },
+    }, evDeps));
+    return { blocked: false, merged };
+}
+function emitBlockedMergeStep(emit, deps, o) {
+    const base = makeEvent({
+        sessionId: o.sessionId,
+        engine: 'choir',
+        paneId: null,
+        parentEventId: o.parentEventId,
+        stage: 'merge-step',
+        summary: `Conflict merging ${o.branch} into ${o.baseBranch} (${o.conflictFiles} file${o.conflictFiles === 1 ? '' : 's'})`,
+        ts: o.ts,
+        refs: { branch: o.branch, blockReason: 'merge-conflict' },
+        metrics: { filesChanged: o.conflictFiles, storyIndex: o.index, storyTotal: o.total },
+    }, deps);
+    emit({ ...base, severity: 'blocked' });
+}
+function gateEvent(deps, o) {
+    const base = makeEvent({
+        sessionId: o.sessionId,
+        engine: 'choir',
+        paneId: null,
+        parentEventId: o.parentEventId,
+        stage: 'build-gate',
+        summary: o.pass
+            ? `Build gate passed after ${o.branch}`
+            : `Build gate FAILED after ${o.branch}`,
+        ts: o.ts,
+        refs: o.pass ? { branch: o.branch } : { branch: o.branch, blockReason: 'build-failed' },
+        metrics: { storyIndex: o.index, storyTotal: o.total, exitCode: o.exitCode },
+    }, deps);
+    return o.pass ? base : { ...base, severity: 'blocked' };
+}
+function blockedEvent(deps, o) {
+    const blockReason = o.reason === 'merge-conflict'
+        ? 'merge-conflict'
+        : o.reason === 'build-failed'
+            ? 'build-failed'
+            : undefined;
+    const summary = o.reason === 'merge-conflict'
+        ? `BLOCKED — conflict on ${o.branch}; human merge gate required`
+        : o.reason === 'build-failed'
+            ? `BLOCKED — build gate failed after ${o.branch}`
+            : `BLOCKED — merge of ${o.branch} could not proceed`;
+    const metrics = { panesComplete: o.merged, paneTotal: o.total };
+    if (typeof o.conflictFiles === 'number')
+        metrics.filesChanged = o.conflictFiles;
+    return makeEvent({
+        sessionId: o.sessionId,
+        engine: 'choir',
+        paneId: null,
+        parentEventId: o.parentEventId,
+        stage: 'reconcile-blocked',
+        summary,
+        ts: o.ts,
+        refs: blockReason ? { branch: o.branch, blockReason } : { branch: o.branch },
+        metrics,
+    }, deps);
+}

package/dist/lib/choir/types.js

@@ -0,0 +1,53 @@
+export const NAME_RE = /^[a-z0-9][a-z0-9-]{0,30}$/;
+export const BRANCH_RE = /^[a-z0-9][a-z0-9/-]{0,60}$/;
+export const PANE_ID_RE = /^%\d+$/;
+export const SUMMARY_MAX = 200;
+export const LOCAL_TEXT_MAX = 4096;
+export const SCHEMA_VERSION = 1;
+export const EGRESS_ALLOWED_TOP_KEYS = Object.freeze([
+    'schemaVersion',
+    'eventId',
+    'sessionId',
+    'engine',
+    'paneId',
+    'parentEventId',
+    'stage',
+    'category',
+    'severity',
+    'terminal',
+    'summary',
+    'ts',
+    'metrics',
+    'refs',
+]);
+export const EGRESS_FORBIDDEN_KEYS = Object.freeze([
+    'paths',
+    'path',
+    'worktreePath',
+    'diff',
+    'patch',
+    'transcript',
+    'content',
+    'fileContents',
+    'token',
+    'pat',
+    'secret',
+    'apiKey',
+    'nonce',
+    'msg',
+]);
+export const HEALTH_DEFAULTS = Object.freeze({
+    SLOW: 90_000,
+    STALL: 8 * 60_000,
+    AWAIT_CONFIRM: 20_000,
+    LOOP_WINDOW: 5 * 60_000,
+    POLL: 5_000,
+    CRASH_GRACE: 10_000,
+});
+export const SEVERITY_WEIGHT = Object.freeze({
+    info: 0,
+    progress: 1,
+    'attention-needed': 2,
+    blocked: 3,
+    error: 4,
+});

package/dist/lib/choir/worktree.js

@@ -0,0 +1,128 @@
+import { spawnSync as nodeSpawnSync } from 'node:child_process';
+import nodeFs from 'node:fs';
+import path from 'node:path';
+import { worktreePathFor, branchFor, assertValidBranch } from './names.js';
+const defaultFs = {
+    existsSync: nodeFs.existsSync,
+    readFileSync: nodeFs.readFileSync,
+    writeFileSync: nodeFs.writeFileSync,
+};
+function runGit(spawnImpl, cwd, args) {
+    return spawnImpl('git', ['-C', cwd, ...args], {
+        encoding: 'utf-8',
+        timeout: 15_000,
+        windowsHide: true,
+    });
+}
+function assertOk(r, op) {
+    if (r.status !== 0) {
+        throw new Error(`git ${op} failed`);
+    }
+}
+export function addWorktree(args) {
+    const { repoRoot, sessionName, paneName, baseBranch, spawnImpl = nodeSpawnSync } = args;
+    const worktreePath = worktreePathFor(repoRoot, sessionName, paneName);
+    const branch = branchFor(sessionName, paneName);
+    assertValidBranch(baseBranch, 'base branch');
+    const r = runGit(spawnImpl, repoRoot, [
+        'worktree',
+        'add',
+        worktreePath,
+        '-b',
+        branch,
+        baseBranch,
+    ]);
+    assertOk(r, 'worktree add');
+    return { worktreePath, branch };
+}
+export function listWorktrees(repoRoot, spawnImpl = nodeSpawnSync) {
+    const r = runGit(spawnImpl, repoRoot, ['worktree', 'list', '--porcelain']);
+    assertOk(r, 'worktree list');
+    const out = typeof r.stdout === 'string' ? r.stdout : '';
+    const entries = [];
+    let cur = null;
+    const flush = () => {
+        if (cur)
+            entries.push(cur);
+        cur = null;
+    };
+    for (const raw of out.split('\n')) {
+        const line = raw.replace(/\r$/, '');
+        if (line === '') {
+            flush();
+            continue;
+        }
+        const sp = line.indexOf(' ');
+        const key = sp === -1 ? line : line.slice(0, sp);
+        const val = sp === -1 ? '' : line.slice(sp + 1);
+        switch (key) {
+            case 'worktree':
+                flush();
+                cur = { worktree: val, detached: false, bare: false };
+                break;
+            case 'HEAD':
+                if (cur)
+                    cur.head = val;
+                break;
+            case 'branch':
+                if (cur)
+                    cur.branch = val.replace(/^refs\/heads\//, '');
+                break;
+            case 'detached':
+                if (cur)
+                    cur.detached = true;
+                break;
+            case 'bare':
+                if (cur)
+                    cur.bare = true;
+                break;
+            default:
+                break;
+        }
+    }
+    flush();
+    return entries;
+}
+export function removeWorktree(args) {
+    const { repoRoot, worktreePath, spawnImpl = nodeSpawnSync } = args;
+    const r = runGit(spawnImpl, repoRoot, ['worktree', 'remove', worktreePath]);
+    assertOk(r, 'worktree remove');
+}
+export function ensureChoirGitignored(repoRoot, fsImpl = defaultFs) {
+    const giPath = path.join(repoRoot, '.gitignore');
+    const ENTRY = '.choir/';
+    let existing = '';
+    if (fsImpl.existsSync(giPath)) {
+        existing = fsImpl.readFileSync(giPath, 'utf-8');
+    }
+    const lines = existing.split('\n').map((l) => l.replace(/\r$/, ''));
+    if (lines.includes(ENTRY))
+        return;
+    const needsNewline = existing.length > 0 && !existing.endsWith('\n');
+    const next = existing + (needsNewline ? '\n' : '') + ENTRY + '\n';
+    fsImpl.writeFileSync(giPath, next);
+}
+export function pollGitStatus(worktreePath, spawnImpl = nodeSpawnSync, base = 'HEAD') {
+    assertValidBranch(base, 'base ref');
+    const st = runGit(spawnImpl, worktreePath, ['status', '--porcelain']);
+    assertOk(st, 'status');
+    const stdout = typeof st.stdout === 'string' ? st.stdout : '';
+    const dirtyPaths = [];
+    for (const raw of stdout.split('\n')) {
+        const line = raw.replace(/\r$/, '');
+        if (line.trim() === '')
+            continue;
+        let p = line.slice(3);
+        const arrow = p.indexOf(' -> ');
+        if (arrow !== -1)
+            p = p.slice(arrow + 4);
+        p = p.replace(/^"(.*)"$/, '$1');
+        if (p.length > 0)
+            dirtyPaths.push(p);
+    }
+    const rev = runGit(spawnImpl, worktreePath, ['rev-list', '--count', `${base}..HEAD`]);
+    assertOk(rev, 'rev-list');
+    const revOut = typeof rev.stdout === 'string' ? rev.stdout.trim() : '';
+    const commitsAhead = Number.parseInt(revOut, 10) || 0;
+    return { dirtyPaths, dirtyFiles: dirtyPaths.length, commitsAhead };
+}

package/dist/lib/completion.js

@@ -60,7 +60,8 @@ export async function checkCompletions(opts) {
         const ok = await postCompletion(baseUrl, pat, id, opts.fetchImpl);
         if (ok) {
             reported.push(id);
-            opts.log?.(`✓ ${id} · run completed (pane closed)\n`);
+            const card = opts.renderComplete?.(id);
+            opts.log?.(card && card.length > 0 ? card : `✓ ${id} · run completed (pane closed)\n`);
         }
     }
     return reported;

package/dist/lib/output.js

@@ -287,6 +287,33 @@ export function pollTick(args) {
     const statusSeg = c.muted(statusText, stream);
     return `${ts}  ${pollCount}  ${sep}  ${sleepSeg}  ${sep}  ${statusSeg}`;
 }
+export function formatElapsed(ms) {
+    if (!Number.isFinite(ms) || ms < 0)
+        return '0s';
+    const totalSec = Math.floor(ms / 1000);
+    if (totalSec < 60)
+        return `${totalSec}s`;
+    const totalMin = Math.floor(totalSec / 60);
+    if (totalMin < 60)
+        return `${totalMin}m ${totalSec % 60}s`;
+    const hours = Math.floor(totalMin / 60);
+    return `${hours}h ${totalMin % 60}m`;
+}
+function summaryAnchor(stream) {
+    const glyph = asciiOnly() ? '*' : '◆';
+    return c.cyan(glyph, stream);
+}
+export function runSummary(args) {
+    const stream = args.stream ?? process.stdout;
+    const failed = args.failed ?? 0;
+    const sep = c.muted('·', stream);
+    const segs = [];
+    segs.push(c.green(`${args.running} running`, stream));
+    segs.push(c.muted(`${args.done} done`, stream));
+    if (failed > 0)
+        segs.push(c.red(`${failed} failed`, stream));
+    return `${summaryAnchor(stream)}  ` + segs.join(`  ${sep}  `);
+}
 export function fixBlock(args) {
     const stream = args.stream ?? process.stdout;
     const title = c.amber(`| ${args.title.toUpperCase()} |`, stream);

package/dist/lib/pane-title.js

@@ -0,0 +1,51 @@
+import { spawnSync as nodeSpawnSync } from 'node:child_process';
+const STATE_GLYPH = {
+    running: '▶',
+    completed: '✓',
+    failed: '✗',
+    stopping: '■',
+};
+const STATE_GLYPH_ASCII = {
+    running: '>',
+    completed: 'OK',
+    failed: 'XX',
+    stopping: '#',
+};
+function asciiOnly(env = process.env) {
+    return env.NONBOT_ASCII_ONLY === '1' || env.NONBOT_ASCII_ONLY === 'true';
+}
+export function paneStateGlyph(state, env = process.env) {
+    return asciiOnly(env) ? STATE_GLYPH_ASCII[state] : STATE_GLYPH[state];
+}
+export const PANE_TITLE_MAX = 44;
+export function formatPaneTitle(state, story, env = process.env) {
+    const glyph = paneStateGlyph(state, env);
+    const cleaned = (story ?? '')
+        .replace(/[\x00-\x1f\x7f]/g, ' ')
+        .replace(/ {2,}/g, ' ')
+        .trim();
+    const label = cleaned.length > 0 ? cleaned : 'nonbot run';
+    const title = `${glyph} ${label}`;
+    return title.length > PANE_TITLE_MAX ? title.slice(0, PANE_TITLE_MAX - 1) + '…' : title;
+}
+export function buildPaneTitleCommand(paneId, state, story, env = process.env) {
+    if (!/^%\d+$/.test(paneId))
+        return null;
+    const title = formatPaneTitle(state, story, env);
+    return { cmd: 'tmux', args: ['select-pane', '-t', paneId, '-T', title] };
+}
+export function applyPaneTitle(paneId, state, story, spawnImpl = nodeSpawnSync, env = process.env) {
+    const command = buildPaneTitleCommand(paneId, state, story, env);
+    if (!command)
+        return false;
+    try {
+        spawnImpl(command.cmd, command.args, {
+            encoding: 'utf-8',
+            timeout: 1000,
+            windowsHide: true,
+        });
+    }
+    catch {
+    }
+    return true;
+}

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.5.15';
+export const VERSION = '0.6.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nonbot/cli",
-  "version": "0.5.15",
+  "version": "0.6.0",
   "type": "module",
   "description": "The local host for non.bot ▶ Run — opens a terminal on your machine and starts the work in your linked repo.",
   "license": "UNLICENSED",