brl-subagent 2.3.4

package/src/concurrency.ts

@@ -0,0 +1,186 @@
+/**
+ * brl-subagent — Concurrency Controller (F8)
+ *
+ * Manages the concurrency queue and progress tracking for subagent execution.
+ * All state is contained in the SessionState instance — no module-level mutable variables.
+ *
+ * F8: Race condition fixes — progress counters are updated atomically within
+ * acquireSlot/releaseSlot, eliminating races between parallel completions.
+ */
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { Priority } from "./types";
+import { PRIORITY_ORDER } from "./types";
+import type { SessionState } from "./state";
+
+// ---------------------------------------------------------------------------
+// Slot management
+// ---------------------------------------------------------------------------
+
+/**
+ * Acquire a concurrency slot. If maxParallel is reached, the caller is queued.
+ * Returns true if a slot was acquired, false if cancelled while waiting.
+ */
+/**
+ * Insert an entry into a priority queue. The entry is placed before the first
+ * item with lower priority (higher numeric value). Equal-priority items maintain
+ * FIFO order (stack behind existing same-priority items).
+ */
+export function priorityInsert<T extends { priority: Priority }>(
+	queue: T[],
+	entry: T,
+): void {
+	const newOrder = PRIORITY_ORDER[entry.priority];
+	const idx = queue.findIndex(
+		(existing) => PRIORITY_ORDER[existing.priority] > newOrder,
+	);
+	if (idx >= 0) {
+		queue.splice(idx, 0, entry);
+	} else {
+		queue.push(entry);
+	}
+}
+
+export async function acquireSlot(
+	state: SessionState,
+	ctx: ExtensionContext,
+	signal?: AbortSignal,
+	priority?: Priority,
+): Promise<boolean> {
+	const maxParallel = state.config.maxParallel;
+
+	if (maxParallel === 0 || state.activeSubagents < maxParallel) {
+		state.activeSubagents++;
+		updateProgressStatus(state, ctx);
+		return true;
+	}
+
+	return new Promise((resolve) => {
+		const entry = {
+			run: () => {
+				state.activeSubagents++;
+				updateProgressStatus(state, ctx);
+				resolve(true);
+			},
+			signal,
+			ctx,
+			priority: priority ?? "normal",
+		};
+		priorityInsert(state.pendingQueue, entry);
+		if (signal) {
+			signal.addEventListener(
+				"abort",
+				() => {
+					const idx = state.pendingQueue.indexOf(entry);
+					if (idx >= 0) {
+						state.pendingQueue.splice(idx, 1);
+						resolve(false);
+					}
+				},
+				{ once: true },
+			);
+		}
+	});
+}
+
+/**
+ * Release a concurrency slot and update progress counters.
+ * This is the single point where counters are mutated — no races.
+ */
+export function releaseSlot(state: SessionState, success: boolean, ctx: ExtensionContext): void {
+	// Atomically update all counters
+	state.activeSubagents--;
+
+	if (state.activeSubagents < 0) {
+		state.activeSubagents = 0; // Defensive: should never happen
+	}
+
+	if (success) {
+		state.completedSubagents++;
+		state.unseenSubagents++;
+	} else {
+		state.failedSubagents++;
+	}
+
+	updateProgressStatus(state, ctx);
+
+	// Dequeue next waiting task
+	const next = state.pendingQueue.shift();
+	if (next && !next.signal?.aborted) {
+		next.run();
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Progress status display
+// ---------------------------------------------------------------------------
+
+const STATUS_RESET_DELAY_MS = 3000;
+
+export function updateProgressStatus(state: SessionState, ctx: ExtensionContext): void {
+	const total = state.activeSubagents + state.completedSubagents + state.failedSubagents;
+
+	if (total === 0) {
+		updateStatus(state, ctx);
+		return;
+	}
+
+	const parts: string[] = [];
+	// Issue #133: prepend the multi-unit mode breakdown when a graph/chain
+	// dispatch is in flight — e.g. "brl: graph wave 1/2 · node 2/3, 2 running".
+	// The mode's finally clears modeContext, so the plain shape returns once
+	// no mode is active.
+	if (state.modeContext) {
+		const mc = state.modeContext;
+		parts.push(
+			mc.kind === "graph"
+				? `graph wave ${mc.wave}/${mc.totalWaves} · node ${mc.node}/${mc.totalNodes}`
+				: `chain step ${mc.step}/${mc.totalSteps}`,
+		);
+	}
+	if (state.activeSubagents > 0) parts.push(`${state.activeSubagents} running`);
+	if (state.completedSubagents > 0) {
+		if (state.unseenSubagents > 0) {
+			parts.push(`${state.completedSubagents} done (${state.unseenSubagents} unseen)`);
+		} else {
+			parts.push(`${state.completedSubagents} done`);
+		}
+	}
+	if (state.failedSubagents > 0) parts.push(`${state.failedSubagents} failed`);
+
+	const statusText = `brl: ${parts.join(", ")}`;
+	ctx.ui.setStatus("brl-subagent", ctx.ui.theme.fg("accent", statusText));
+
+	// When all subagents finish, reset counters after a brief delay
+	if (state.activeSubagents === 0 && total > 0) {
+		const snapshotTotal = total;
+		setTimeout(() => {
+			if (
+				state.activeSubagents === 0 &&
+				state.completedSubagents + state.failedSubagents === snapshotTotal
+			) {
+				state.completedSubagents = 0;
+				state.failedSubagents = 0;
+				state.unseenSubagents = 0;
+				updateStatus(state, ctx);
+			}
+		}, STATUS_RESET_DELAY_MS);
+	}
+}
+
+export function updateStatus(state: SessionState, ctx: ExtensionContext): void {
+	if (state.config.model) {
+		ctx.ui.setStatus(
+			"brl-subagent",
+			ctx.ui.theme.fg(
+				"accent",
+				`brl:${state.config.model.id} [max think:${state.config.maxThinkingLevel}]`,
+			),
+		);
+	} else {
+		ctx.ui.setStatus(
+			"brl-subagent",
+			ctx.ui.theme.fg("muted", "brl: (use /brl-subagent to configure)"),
+		);
+	}
+}

package/src/diff.ts

@@ -0,0 +1,102 @@
+/**
+ * brl-subagent — Git Diff Parser (P5)
+ *
+ * Parses standard git unified diff output into structured file-level summaries.
+ */
+
+import { MAX_HUNKS_PER_FILE, type FileDiff } from "./types";
+
+/**
+ * Parse standard git unified diff output.
+ *
+ * For each file in the diff:
+ * 1. Extract file path from the "diff --git" line
+ * 2. Count lines starting with - (deletions) and + (additions)
+ * 3. Collect hunk strings: each hunk is the full text from @@ to the next @@ or next file
+ *
+ * Limit: caps hunks per file to MAX_HUNKS_PER_FILE (10). totalHunks stores the real count.
+ *
+ * Returns an array sorted by path name (alphabetical, stable).
+ * Returns empty array for empty or whitespace-only input.
+ */
+export function parseDiff(rawDiff: string): FileDiff[] {
+	if (!rawDiff || !rawDiff.trim()) return [];
+
+	const lines = rawDiff.split("\n");
+	const files: FileDiff[] = [];
+
+	let currentPath = "";
+	let currentHunks: string[] = [];
+	let currentAdditions = 0;
+	let currentDeletions = 0;
+	let hunkLines: string[] | null = null; // null = not inside a hunk
+
+	function saveCurrentFile(): void {
+		if (!currentPath) return;
+		if (hunkLines && hunkLines.length > 0) {
+			currentHunks.push(hunkLines.join("\n"));
+		}
+		files.push({
+			path: currentPath,
+			additions: currentAdditions,
+			deletions: currentDeletions,
+			hunks: currentHunks.slice(0, MAX_HUNKS_PER_FILE),
+			totalHunks: currentHunks.length,
+		});
+	}
+
+	function resetFileState(): void {
+		currentPath = "";
+		currentHunks = [];
+		currentAdditions = 0;
+		currentDeletions = 0;
+		hunkLines = null;
+	}
+
+	for (const line of lines) {
+		// New file starts
+		if (line.startsWith("diff --git ")) {
+			saveCurrentFile();
+			resetFileState();
+			const m = line.match(/^diff --git a\/(.+) b\/(.+)$/);
+			currentPath = m ? m[2] : "unknown";
+			continue;
+		}
+
+		// Hunk header
+		if (line.startsWith("@@")) {
+			if (hunkLines && hunkLines.length > 0) {
+				currentHunks.push(hunkLines.join("\n"));
+			}
+			hunkLines = [line];
+			continue;
+		}
+
+		// Track additions (skip +++ header)
+		if (line.startsWith("+") && !line.startsWith("+++")) {
+			currentAdditions++;
+			if (hunkLines !== null) hunkLines.push(line);
+			continue;
+		}
+
+		// Track deletions (skip --- header)
+		if (line.startsWith("-") && !line.startsWith("---")) {
+			currentDeletions++;
+			if (hunkLines !== null) hunkLines.push(line);
+			continue;
+		}
+
+		// Context line inside a hunk
+		if (hunkLines !== null) {
+			hunkLines.push(line);
+		}
+	}
+
+	// Last file
+	saveCurrentFile();
+
+	// Sort by path (alphabetical, stable — plain localeCompare suffices for git paths)
+	files.sort((a, b) => a.path.localeCompare(b.path));
+
+	return files;
+}

package/src/event-bus.ts

@@ -0,0 +1,86 @@
+import type { SubagentEvent, SubagentEventType, SubagentEventListener } from './types';
+
+// Event listeners by type
+const listeners = new Map<SubagentEventType, Set<SubagentEventListener>>();
+
+// Global listeners (receive all events)
+const globalListeners = new Set<SubagentEventListener>();
+
+/**
+ * Subscribe a listener to a specific event type.
+ *
+ * @param type - The event type to subscribe to
+ * @param listener - The listener invoked for each event of this type
+ */
+export function on(type: SubagentEventType, listener: SubagentEventListener): void {
+	let typeListeners = listeners.get(type);
+	if (!typeListeners) {
+		typeListeners = new Set();
+		listeners.set(type, typeListeners);
+	}
+	typeListeners.add(listener);
+}
+
+/**
+ * Unsubscribe a listener from a specific event type.
+ *
+ * @param type - The event type to unsubscribe from
+ * @param listener - The listener to remove
+ */
+export function off(type: SubagentEventType, listener: SubagentEventListener): void {
+	const typeListeners = listeners.get(type);
+	if (!typeListeners) return;
+	typeListeners.delete(listener);
+	if (typeListeners.size === 0) listeners.delete(type);
+}
+
+/**
+ * Emit an event
+ * 
+ * @param event - The event to emit
+ */
+export function emit(event: SubagentEvent): void {
+  // Notify type-specific listeners
+  const typeListeners = listeners.get(event.type);
+  if (typeListeners) {
+    for (const listener of typeListeners) {
+      try {
+        listener(event);
+      } catch (err) {
+        // Don't let listener errors break the event loop
+        console.error(`[event-bus] Listener error for ${event.type}:`, err);
+      }
+    }
+  }
+  
+  // Notify global listeners
+  for (const listener of globalListeners) {
+    try {
+      listener(event);
+    } catch (err) {
+      console.error(`[event-bus] Global listener error:`, err);
+    }
+  }
+}
+
+
+/**
+ * Create a SubagentEvent helper
+ * 
+ * @param type - The event type
+ * @param agentId - The agent ID
+ * @param data - Additional event data
+ * @returns SubagentEvent object
+ */
+export function createEvent(
+  type: SubagentEventType,
+  agentId: string,
+  data: Record<string, unknown> = {}
+): SubagentEvent {
+  return {
+    type,
+    agentId,
+    timestamp: Date.now(),
+    data,
+  };
+}

package/src/git.ts

@@ -0,0 +1,187 @@
+/**
+ * brl-subagent — Git Integration (P3)
+ *
+ * Branch-based git workflow for subagent isolation.
+ * All git commands use execFileSync with a 10-second timeout.
+ */
+
+import { execFileSync } from "node:child_process";
+
+// ---------------------------------------------------------------------------
+// Options for git commands
+// ---------------------------------------------------------------------------
+
+function gitOpts(cwd: string) {
+	return {
+		cwd,
+		encoding: "utf-8" as const,
+		timeout: 10_000,
+	};
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Get the current branch name.
+ * Throws if the cwd is not a git repository.
+ */
+export function getCurrentBranch(cwd: string): string {
+	const output = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], gitOpts(cwd));
+	return output.trim();
+}
+
+/**
+ * Check if there are uncommitted changes in the working tree.
+ */
+export function hasUncommittedChanges(cwd: string): boolean {
+	const output = execFileSync("git", ["status", "--porcelain"], gitOpts(cwd));
+	return output.trim().length > 0;
+}
+
+/**
+ * Create a work branch from the given base branch.
+ * Returns { ok: true, branch } on success, { ok: false, error } on failure.
+ */
+export function createWorkBranch(
+	cwd: string,
+	baseBranch: string,
+): { ok: true; branch: string } | { ok: false; error: string } {
+	try {
+		const branch = "brl-subagent-" + crypto.randomUUID().slice(0, 8);
+		execFileSync("git", ["checkout", "-b", branch, baseBranch], gitOpts(cwd));
+		return { ok: true, branch };
+	} catch (err) {
+		return { ok: false, error: (err as Error).message };
+	}
+}
+
+/**
+ * Capture the unified diff between baseBranch and HEAD.
+ * Returns { ok: true, diff } on success, { ok: false, error } on failure.
+ */
+export function captureDiff(
+	cwd: string,
+	baseBranch: string,
+): { ok: true; diff: string } | { ok: false; error: string } {
+	try {
+		const output = execFileSync("git", ["diff", `${baseBranch}...HEAD`], gitOpts(cwd));
+		return { ok: true, diff: output };
+	} catch (err) {
+		return { ok: false, error: (err as Error).message };
+	}
+}
+
+/**
+ * Switch to an existing branch.
+ * Returns { ok: true } on success, { ok: false, error } on failure.
+ */
+export function switchToBranch(
+	cwd: string,
+	branch: string,
+): { ok: true } | { ok: false; error: string } {
+	try {
+		execFileSync("git", ["checkout", branch], gitOpts(cwd));
+		return { ok: true };
+	} catch (err) {
+		return { ok: false, error: (err as Error).message };
+	}
+}
+
+/**
+ * Merge a work branch into the current branch.
+ * Uses --no-edit to prevent opening an editor.
+ * Returns { ok: true } on success, { ok: false, error } on failure.
+ */
+export function mergeWorkBranch(
+	cwd: string,
+	branch: string,
+): { ok: true } | { ok: false; error: string } {
+	try {
+		execFileSync("git", ["merge", branch, "--no-edit"], gitOpts(cwd));
+		return { ok: true };
+	} catch (err) {
+		return { ok: false, error: (err as Error).message };
+	}
+}
+
+/**
+ * Delete a branch.
+ * Returns { ok: true } on success, { ok: false, error } on failure.
+ */
+export function deleteBranch(
+	cwd: string,
+	branch: string,
+): { ok: true } | { ok: false; error: string } {
+	try {
+		execFileSync("git", ["branch", "-D", branch], gitOpts(cwd));
+		return { ok: true };
+	} catch (err) {
+		return { ok: false, error: (err as Error).message };
+	}
+}
+
+/**
+ * Stage and commit ALL changes (tracked + untracked) on the current branch.
+ * Used by background gitMode=branch teardown: the agent's work is committed to
+ * the work branch BEFORE the diff is captured and the branch is discarded —
+ * `git diff base...HEAD` only sees committed changes, and switching back with
+ * uncommitted edits would carry them into the base working tree (C1).
+ * Returns { ok: true, sha } on success, { ok: false, error } on failure
+ * (e.g. no git identity configured).
+ */
+export function commitAll(
+	cwd: string,
+	message: string,
+): { ok: true; sha: string } | { ok: false; error: string } {
+	try {
+		execFileSync("git", ["add", "-A"], gitOpts(cwd));
+		execFileSync("git", ["commit", "-m", message], gitOpts(cwd));
+		const sha = execFileSync("git", ["rev-parse", "HEAD"], gitOpts(cwd)).trim();
+		return { ok: true, sha };
+	} catch (err) {
+		return { ok: false, error: (err as Error).message };
+	}
+}
+
+/**
+ * Capture the WORKING-TREE diff (unstaged + staged + untracked, i.e.
+ * everything `git diff base...HEAD` misses when the agent never committed).
+ * Untracked files are surfaced via intent-to-add (`git add -N`) WITHOUT
+ * staging their content, and the index is restored to its original state —
+ * the intent-to-add marks are removed with a path-limited reset that leaves
+ * genuinely staged entries untouched. Returns the merged patch text, or
+ * undefined when the tree is clean.
+ */
+export function captureWorkingDiff(cwd: string): string | undefined {
+	let untracked: string[] = [];
+	try {
+		// Identify untracked files FIRST — only these need intent-to-add marks.
+		untracked = execFileSync("git", ["ls-files", "--others", "--exclude-standard"], gitOpts(cwd))
+			.toString().split("\n").filter(Boolean);
+	} catch {
+		return undefined;
+	}
+	try {
+		// Capture staged + unstaged (tracked) first — no index mutation yet.
+		const unstaged = execFileSync("git", ["diff"], gitOpts(cwd)).toString();
+		const staged = execFileSync("git", ["diff", "--cached"], gitOpts(cwd)).toString();
+		let untrackedDiff = "";
+		if (untracked.length > 0) {
+			// Surface untracked files via intent-to-add, WITHOUT staging content.
+			execFileSync("git", ["add", "-N", "--", ...untracked], gitOpts(cwd));
+			untrackedDiff = execFileSync("git", ["diff"], gitOpts(cwd)).toString();
+			// Remove ONLY the intent-to-add marks — real staged entries are preserved.
+			execFileSync("git", ["reset", "-q", "--", ...untracked], gitOpts(cwd));
+		}
+		const merged = `${unstaged}${untrackedDiff}${staged}`.trim();
+		return merged.length > 0 ? merged : undefined;
+	} catch {
+		try {
+			// Best-effort index restore even if a diff command failed mid-way.
+			if (untracked.length > 0) execFileSync("git", ["reset", "-q", "--", ...untracked], gitOpts(cwd));
+		} catch { /* ignore */ }
+		return undefined;
+	}
+}