@nonbot/cli 0.9.3 → 0.9.4

package/dist/commands/daemon.js

@@ -6,7 +6,8 @@ import { checkCompletions } from '../lib/completion.js';
 import { deliverAnsweredPrompts } from '../lib/run-prompt.js';
 import { loadOrCreateMachineId, resolveMachineName } from '../lib/machine.js';
 import { emitRunStage as defaultEmitRunStage, startRunHeartbeat as defaultStartRunHeartbeat, RUN_STAGE, } from '../lib/choir/run-progress.js';
-import { groupBySession, launchCoordinatedSet, } from '../lib/choir/coordinated-set.js';
+import { groupBySession, launchCoordinatedSet, setIsIsolated, } from '../lib/choir/coordinated-set.js';
+import { IsolatedSessionTracker, reconcileAndCleanup as defaultReconcileAndCleanup, resolveBaseBranch as defaultResolveBaseBranch, } from '../lib/choir/isolated-session.js';
 import { applyPaneTitle } from '../lib/pane-title.js';
 import { installService, uninstallService } from '../lib/service.js';
 import { detectTmuxSession, inTmuxSession, nonbotTmuxOptOut, resolveTerminal, } from '../lib/terminal.js';
@@ -193,6 +194,10 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
     const seen = new Set();
     const launchedSessions = new Set();
     const launchCoordinatedSetFn = deps.launchCoordinatedSet ?? launchCoordinatedSet;
+    const isolatedSessions = deps.isolatedSessions ?? new IsolatedSessionTracker();
+    const reconcileAndCleanupFn = deps.reconcileAndCleanup ?? defaultReconcileAndCleanup;
+    const resolveBaseBranchFn = deps.resolveBaseBranch ?? defaultResolveBaseBranch;
+    const reconcileBuildCommand = deps.reconcileBuildCommand ?? process.env.NONBOT_RECONCILE_BUILD_CMD ?? '';
     const trackedPanes = new Map();
     const killedByStop = new Set();
     const injectedPrompts = new Set();
@@ -351,6 +356,11 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                 const acts = body?.activations ?? [];
                 const { singletons, sets } = groupBySession(acts);
                 for (const [choirSessionId, setActs] of sets) {
+                    if (!setIsIsolated(setActs)) {
+                        for (const a of setActs)
+                            singletons.push(a);
+                        continue;
+                    }
                     for (const a of setActs)
                         if (a?.id)
                             seen.add(a.id);
@@ -396,6 +406,22 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                             catch {
                             }
                         }
+                        try {
+                            isolatedSessions.register({
+                                choirSessionId,
+                                sessionId: result.sessionId,
+                                repoRoot: result.repoRoot,
+                                baseBranch: resolveBaseBranchFn(result.repoRoot, deps.spawnSync),
+                                buildTestCommand: reconcileBuildCommand,
+                                panes: result.panes.map((p) => ({
+                                    activationId: p.activationId,
+                                    branch: p.branch,
+                                    worktreePath: p.worktreePath,
+                                })),
+                            });
+                        }
+                        catch {
+                        }
                         lastFailureReason = null;
                         emitSummary();
                     }
@@ -512,6 +538,20 @@ export async function runDaemonCommand(args = [], options = {}, deps = {}) {
                             trackedMeta.delete(id);
                             safeEmit(id, RUN_STAGE.FINISHED);
                             stopHeartbeat(id, 'daemon-exit');
+                            try {
+                                const session = isolatedSessions.noteTerminal(id);
+                                if (session) {
+                                    reconcileAndCleanupFn(session, {
+                                        spawnImpl: deps.spawnSync,
+                                        log,
+                                    });
+                                }
+                            }
+                            catch (e) {
+                                errLog(statusRow('⚠', 'reconcile failed', e.message, {
+                                    stream: process.stderr,
+                                }) + '\n');
+                            }
                         }
                         emitSummary();
                     }

package/dist/lib/choir/coordinated-set.js

@@ -25,6 +25,12 @@ export function choirSessionIdOf(act) {
         ? p.choirSessionId
         : null;
 }
+export function isolateOf(act) {
+    return payloadOf(act).isolate === true;
+}
+export function setIsIsolated(activations) {
+    return Array.isArray(activations) && activations.some(isolateOf);
+}
 export function groupBySession(activations) {
     const singletons = [];
     const sets = new Map();

package/dist/lib/choir/isolated-session.js

@@ -0,0 +1,92 @@
+import { spawnSync as nodeSpawnSync } from 'node:child_process';
+import { removeWorktree as defaultRemoveWorktree } from './worktree.js';
+import { runReconcile as defaultRunReconcile } from './reconcile.js';
+import { isValidBranch } from './names.js';
+export class IsolatedSessionTracker {
+    sessions = new Map();
+    register(a) {
+        if (this.sessions.has(a.choirSessionId))
+            return;
+        this.sessions.set(a.choirSessionId, {
+            choirSessionId: a.choirSessionId,
+            sessionId: a.sessionId,
+            repoRoot: a.repoRoot,
+            baseBranch: a.baseBranch,
+            buildTestCommand: a.buildTestCommand ?? '',
+            panes: a.panes,
+            pending: new Set(a.panes.map((p) => p.activationId)),
+        });
+    }
+    tracks(activationId) {
+        for (const s of this.sessions.values()) {
+            if (s.pending.has(activationId))
+                return true;
+        }
+        return false;
+    }
+    noteTerminal(activationId) {
+        for (const s of this.sessions.values()) {
+            if (!s.pending.delete(activationId))
+                continue;
+            if (s.pending.size === 0) {
+                this.sessions.delete(s.choirSessionId);
+                return s;
+            }
+            return null;
+        }
+        return null;
+    }
+    get size() {
+        return this.sessions.size;
+    }
+}
+export function resolveBaseBranch(repoRoot, spawnImpl = nodeSpawnSync) {
+    try {
+        const r = spawnImpl('git', ['-C', repoRoot, 'rev-parse', '--abbrev-ref', 'HEAD'], {
+            encoding: 'utf-8',
+            timeout: 5000,
+            windowsHide: true,
+        });
+        const name = typeof r.stdout === 'string' ? r.stdout.trim() : '';
+        if (isValidBranch(name))
+            return name;
+    }
+    catch {
+    }
+    return 'main';
+}
+export function reconcileAndCleanup(session, deps = {}) {
+    const spawnImpl = deps.spawnImpl ?? nodeSpawnSync;
+    const runReconcileImpl = deps.runReconcileImpl ?? defaultRunReconcile;
+    const removeWorktreeImpl = deps.removeWorktreeImpl ?? defaultRemoveWorktree;
+    const log = deps.log;
+    const branches = session.panes.map((p) => p.branch);
+    const reconcile = runReconcileImpl({
+        repoRoot: session.repoRoot,
+        baseBranch: session.baseBranch,
+        branches,
+        buildTestCommand: session.buildTestCommand,
+        sessionId: session.sessionId,
+        spawnImpl,
+        emit: deps.emit,
+    });
+    const removed = [];
+    if (!reconcile.blocked) {
+        for (const p of session.panes) {
+            try {
+                removeWorktreeImpl({ repoRoot: session.repoRoot, worktreePath: p.worktreePath });
+                removed.push(p.worktreePath);
+            }
+            catch {
+            }
+        }
+        log?.(`[reconcile] ${session.sessionId} — merged ${reconcile.merged.length} ` +
+            `branch${reconcile.merged.length === 1 ? '' : 'es'}, ` +
+            `removed ${removed.length} worktree${removed.length === 1 ? '' : 's'}\n`);
+    }
+    else {
+        log?.(`[reconcile] ${session.sessionId} — BLOCKED (${reconcile.reason}); ` +
+            `worktrees kept for the human merge gate\n`);
+    }
+    return { reconcile, removed };
+}

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.9.3';
+export const VERSION = '0.9.4';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nonbot/cli",
-  "version": "0.9.3",
+  "version": "0.9.4",
   "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",