xtrm-tools 0.5.26 → 0.5.28

package/config/pi/extensions/custom-footer/index.ts

@@ -1,11 +1,13 @@
 /**
  * XTRM Custom Footer Extension
  *
- * Displays: XTRM brand, Model, Context%, CWD, Git branch, Beads chip
+ * Displays: XTRM brand, model/context, host, cwd, git branch/status, beads state.
  */
 
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { truncateToWidth } from "@mariozechner/pi-tui";
+import { basename, relative } from "node:path";
+import { hostname } from "node:os";
 
 import { SubprocessRunner, EventAdapter } from "../core/lib";
 
@@ -13,25 +15,34 @@ export default function (pi: ExtensionAPI) {
 	interface BeadState {
 		claimId: string | null;
 		shortId: string | null;
+		claimTitle: string | null;
 		status: string | null;
 		openCount: number;
 		lastFetch: number;
 	}
 
+	interface RuntimeState {
+		host: string;
+		displayDir: string;
+		branch: string | null;
+		gitStatus: string;
+		venv: string | null;
+		lastFetch: number;
+	}
+
 	const STATUS_ICONS: Record<string, string> = {
 		open: "○",
 		in_progress: "◐",
 		blocked: "●",
 		closed: "✓",
 	};
+
 	// Chip background colours (raw ANSI — theme has no bg() API)
-	const CHIP_BG_NEUTRAL  = "\x1b[48;5;238m"; // dark gray
-	const CHIP_BG_ACTIVE   = "\x1b[48;5;39m";  // blue
-	const CHIP_BG_BLOCKED  = "\x1b[48;5;88m";  // red
-	const CHIP_FG          = "\x1b[38;5;15m";  // white
-	const CHIP_RESET       = "\x1b[0m";
-	const chip = (text: string, bg = CHIP_BG_NEUTRAL): string =>
-		`${bg}${CHIP_FG} ${text} ${CHIP_RESET}`;
+	const CHIP_BG_NEUTRAL = "\x1b[48;5;238m";
+	const CHIP_BG_ACTIVE = "\x1b[48;5;39m";
+	const CHIP_BG_BLOCKED = "\x1b[48;5;88m";
+	const CHIP_FG = "\x1b[38;5;15m";
+	const CHIP_RESET = "\x1b[0m";
 
 	const STATUS_BG: Record<string, string> = {
 		open: CHIP_BG_NEUTRAL,
@@ -39,35 +50,144 @@ export default function (pi: ExtensionAPI) {
 		blocked: CHIP_BG_BLOCKED,
 	};
 
+	const chip = (text: string, bg = CHIP_BG_NEUTRAL): string => `${bg}${CHIP_FG} ${text} ${CHIP_RESET}`;
+
 	let capturedCtx: any = null;
-	let sessionId: string = "";
-	let beadState: BeadState = { claimId: null, shortId: null, status: null, openCount: 0, lastFetch: 0 };
-	let refreshing = false;
+	let sessionId = "";
 	let requestRender: (() => void) | null = null;
+
 	const CACHE_TTL = 5000;
+	let refreshingBeads = false;
+	let refreshingRuntime = false;
+
+	let beadState: BeadState = {
+		claimId: null,
+		shortId: null,
+		claimTitle: null,
+		status: null,
+		openCount: 0,
+		lastFetch: 0,
+	};
+
+	let runtimeState: RuntimeState = {
+		host: hostname().split(".")[0] || "host",
+		displayDir: process.cwd(),
+		branch: null,
+		gitStatus: "",
+		venv: process.env.VIRTUAL_ENV ? basename(process.env.VIRTUAL_ENV) : null,
+		lastFetch: 0,
+	};
 
 	const getCwd = () => capturedCtx?.cwd || process.cwd();
 	const getShortId = (id: string) => id.split("-").pop() ?? id;
 
+	const parseGitFlags = (porcelain: string): string => {
+		let modified = false;
+		let staged = false;
+		let deleted = false;
+		for (const line of porcelain.split("\n").filter(Boolean)) {
+			if (/^ M|^AM|^MM/.test(line)) modified = true;
+			if (/^A |^M /.test(line)) staged = true;
+			if (/^ D|^D /.test(line)) deleted = true;
+		}
+		return `${modified ? "*" : ""}${staged ? "+" : ""}${deleted ? "-" : ""}`;
+	};
+
+	const refreshRuntimeState = async () => {
+		if (refreshingRuntime || Date.now() - runtimeState.lastFetch < CACHE_TTL) return;
+		refreshingRuntime = true;
+		const cwd = getCwd();
+		try {
+			const host = hostname().split(".")[0] || "host";
+			const venv = process.env.VIRTUAL_ENV ? basename(process.env.VIRTUAL_ENV) : null;
+			const rootResult = await SubprocessRunner.run("git", ["rev-parse", "--show-toplevel"], { cwd });
+			const repoRoot = rootResult.code === 0 ? rootResult.stdout.trim() : null;
+
+			const displayDir = repoRoot
+				? (() => {
+					const relPath = relative(repoRoot, cwd) || ".";
+					return relPath === "." ? basename(repoRoot) : `${basename(repoRoot)}/${relPath}`;
+				  })()
+				: (() => {
+					const parts = cwd.split("/");
+					return parts.length > 2 ? parts.slice(-2).join("/") : cwd;
+				  })();
+
+			let branch: string | null = null;
+			let gitStatus = "";
+			if (repoRoot) {
+				const branchResult = await SubprocessRunner.run("git", ["branch", "--show-current"], { cwd });
+				branch = branchResult.code === 0 ? branchResult.stdout.trim() || null : null;
+
+				const porcelainResult = await SubprocessRunner.run("git", ["--no-optional-locks", "status", "--porcelain"], { cwd });
+				const baseFlags = porcelainResult.code === 0 ? parseGitFlags(porcelainResult.stdout) : "";
+
+				let upstreamFlags = "";
+				const abResult = await SubprocessRunner.run(
+					"git",
+					["--no-optional-locks", "rev-list", "--left-right", "--count", "@{upstream}...HEAD"],
+					{ cwd },
+				);
+				if (abResult.code === 0) {
+					const [behindRaw, aheadRaw] = abResult.stdout.trim().split(/\s+/);
+					const behind = Number(behindRaw || 0);
+					const ahead = Number(aheadRaw || 0);
+					if (ahead > 0 && behind > 0) upstreamFlags = "↕";
+					else if (ahead > 0) upstreamFlags = "↑";
+					else if (behind > 0) upstreamFlags = "↓";
+				}
+
+				gitStatus = `${baseFlags}${upstreamFlags}`;
+			}
+
+			runtimeState = {
+				host,
+				displayDir,
+				branch,
+				gitStatus,
+				venv,
+				lastFetch: Date.now(),
+			};
+			requestRender?.();
+		} catch {
+			// Fail soft — keep last known runtime state.
+		} finally {
+			refreshingRuntime = false;
+		}
+	};
+
 	const refreshBeadState = async () => {
-		if (refreshing || Date.now() - beadState.lastFetch < CACHE_TTL) return;
+		if (refreshingBeads || Date.now() - beadState.lastFetch < CACHE_TTL) return;
 		const cwd = getCwd();
-		if (!EventAdapter.isBeadsProject(cwd)) return;
-		if (!sessionId) return;
-		refreshing = true;
+		if (!EventAdapter.isBeadsProject(cwd) || !sessionId) return;
+		refreshingBeads = true;
 		try {
 			const claimResult = await SubprocessRunner.run("bd", ["kv", "get", `claimed:${sessionId}`], { cwd });
 			const claimId = claimResult.code === 0 ? claimResult.stdout.trim() || null : null;
 
 			let status: string | null = null;
+			let claimTitle: string | null = null;
 			if (claimId) {
 				const showResult = await SubprocessRunner.run("bd", ["show", claimId, "--json"], { cwd });
 				if (showResult.code === 0) {
-					try { status = JSON.parse(showResult.stdout)[0]?.status ?? null; } catch {}
+					try {
+						const issue = JSON.parse(showResult.stdout)?.[0];
+						status = issue?.status ?? null;
+						claimTitle = issue?.title ?? null;
+					} catch {
+						// keep nulls
+					}
 				}
 				if (status === "closed") {
 					await SubprocessRunner.run("bd", ["kv", "clear", `claimed:${sessionId}`], { cwd });
-					beadState = { claimId: null, shortId: null, status: null, openCount: beadState.openCount, lastFetch: Date.now() };
+					beadState = {
+						claimId: null,
+						shortId: null,
+						claimTitle: null,
+						status: null,
+						openCount: beadState.openCount,
+						lastFetch: Date.now(),
+					};
 					requestRender?.();
 					return;
 				}
@@ -80,10 +200,20 @@ export default function (pi: ExtensionAPI) {
 				if (m) openCount = parseInt(m[1], 10);
 			}
 
-			beadState = { claimId, shortId: claimId ? getShortId(claimId) : null, status, openCount, lastFetch: Date.now() };
+			beadState = {
+				claimId,
+				shortId: claimId ? getShortId(claimId) : null,
+				claimTitle,
+				status,
+				openCount,
+				lastFetch: Date.now(),
+			};
 			requestRender?.();
-		} catch {}
-		finally { refreshing = false; }
+		} catch {
+			// Fail soft — keep last known beads state.
+		} finally {
+			refreshingBeads = false;
+		}
 	};
 
 	const buildBeadChip = (): string => {
@@ -93,68 +223,134 @@ export default function (pi: ExtensionAPI) {
 			const bg = STATUS_BG[status] ?? CHIP_BG_NEUTRAL;
 			return chip(`bd:${shortId}${icon}`, bg);
 		}
+		if (openCount > 0) return chip(`bd:${openCount}${STATUS_ICONS.open}`);
+		return "";
+	};
+
+	const buildIssueLine = (width: number, theme: any): string => {
+		const { shortId, claimTitle, openCount } = beadState;
+		if (shortId && claimTitle) {
+			const prefix = `◐ ${shortId} `;
+			const title = theme.fg("muted", claimTitle);
+			return truncateToWidth(`${prefix}${title}`, width);
+		}
 		if (openCount > 0) {
-			return chip(`bd:${openCount}${STATUS_ICONS.open}`);
+			return truncateToWidth(`○ ${openCount} open`, width);
 		}
-		return "";
+		return truncateToWidth("○ no open issues", width);
 	};
 
-	pi.on("session_start", async (_event, ctx) => {
-		capturedCtx = ctx;
-		// Get session ID from sessionManager/context (prefer UUID, consistent with hooks)
-		sessionId = ctx.sessionManager?.getSessionId?.() ?? ctx.sessionId ?? ctx.session_id ?? process.pid.toString();
+	let footerReapplyTimer: ReturnType<typeof setTimeout> | null = null;
 
+	const applyCustomFooter = (ctx: any) => {
+		capturedCtx = ctx;
 		ctx.ui.setFooter((tui, theme, footerData) => {
 			requestRender = () => tui.requestRender();
-			const unsub = footerData.onBranchChange(() => tui.requestRender());
+			const unsub = footerData.onBranchChange(() => {
+				runtimeState.lastFetch = 0;
+				tui.requestRender();
+			});
 
 			return {
-				dispose() { unsub(); requestRender = null; },
+				dispose() {
+					unsub();
+					requestRender = null;
+				},
 				invalidate() {},
 				render(width: number): string[] {
+					refreshRuntimeState().catch(() => {});
 					refreshBeadState().catch(() => {});
 
-					const BOLD = "\x1b[1m", BOLD_OFF = "\x1b[22m";
+					const BOLD = "\x1b[1m";
+					const BOLD_OFF = "\x1b[22m";
 					const brand = `${BOLD}${theme.fg("accent", "XTRM")}${BOLD_OFF}`;
 
 					const usage = ctx.getContextUsage();
 					const pct = usage?.percent ?? 0;
 					const pctColor = pct > 75 ? "error" : pct > 50 ? "warning" : "success";
-					const usageStr = theme.fg(pctColor, `${pct.toFixed(0)}%`);
-
-					const parts = process.cwd().split("/");
-					const short = parts.length > 2 ? parts.slice(-2).join("/") : process.cwd();
-					const cwdStr = theme.fg("muted", `⌂ ${short}`);
-
-					const branch = footerData.getGitBranch();
-					const branchStr = branch ? theme.fg("accent", `⎇ ${branch}`) : "";
+					const usageStr = theme.fg(pctColor, `[${pct.toFixed(0)}%]`);
 
 					const modelId = ctx.model?.id || "no-model";
-					const modelChip = chip(modelId);
-
-					const sep = " ";
+					const modelStr = `${modelId} ${usageStr}`;
 
-					const brandModel = `${brand} ${modelChip}`;
+					const branchFromFooter = footerData.getGitBranch();
+					const branch = runtimeState.branch || branchFromFooter;
+					const branchWithStatus = branch
+						? runtimeState.gitStatus
+							? `${branch} (${runtimeState.gitStatus})`
+							: branch
+						: "";
+					const branchStr = branchWithStatus ? theme.fg("muted", branchWithStatus) : "";
+					const hostStr = theme.fg("muted", runtimeState.host);
+					const cwdStr = `${BOLD}${runtimeState.displayDir}${BOLD_OFF}`;
+					const venvStr = runtimeState.venv ? theme.fg("muted", `(${runtimeState.venv})`) : "";
 					const beadChip = buildBeadChip();
-					const leftParts = [brandModel, usageStr];
-					if (beadChip) leftParts.push(beadChip);
-					leftParts.push(cwdStr);
-					if (branchStr) leftParts.push(branchStr);
 
-					const left = leftParts.join(sep);
-					return [truncateToWidth(left, width)];
+					const line1Parts = [brand, modelStr, hostStr, cwdStr];
+					if (branchStr) line1Parts.push(branchStr);
+					if (venvStr) line1Parts.push(venvStr);
+					if (beadChip) line1Parts.push(beadChip);
+
+					const line1 = truncateToWidth(line1Parts.join(" "), width);
+					const line2 = buildIssueLine(width, theme);
+					return [line1, line2];
 				},
 			};
 		});
+	};
+
+	const scheduleFooterReapply = (ctx: any, delayMs = 40) => {
+		if (footerReapplyTimer) clearTimeout(footerReapplyTimer);
+		footerReapplyTimer = setTimeout(() => {
+			applyCustomFooter(ctx);
+			footerReapplyTimer = null;
+		}, delayMs);
+	};
+
+	pi.on("session_start", async (_event, ctx) => {
+		capturedCtx = ctx;
+		sessionId = ctx.sessionManager?.getSessionId?.() ?? ctx.sessionId ?? ctx.session_id ?? process.pid.toString();
+		runtimeState.lastFetch = 0;
+		beadState.lastFetch = 0;
+		applyCustomFooter(ctx);
+		scheduleFooterReapply(ctx);
+	});
+
+	pi.on("session_switch", async (_event, ctx) => {
+		runtimeState.lastFetch = 0;
+		scheduleFooterReapply(ctx);
+	});
+
+	pi.on("session_fork", async (_event, ctx) => {
+		runtimeState.lastFetch = 0;
+		scheduleFooterReapply(ctx);
 	});
 
-	// Bust the bead cache immediately after any bd write
+	pi.on("model_select", async (_event, ctx) => {
+		runtimeState.lastFetch = 0;
+		scheduleFooterReapply(ctx);
+	});
+
+	pi.on("session_shutdown", async () => {
+		if (footerReapplyTimer) {
+			clearTimeout(footerReapplyTimer);
+			footerReapplyTimer = null;
+		}
+	});
+
+	// Bust caches immediately after relevant writes
 	pi.on("tool_result", async (event: any) => {
 		const cmd = event?.input?.command;
-		if (cmd && /\bbd\s+(close|update|create|claim)\b/.test(cmd)) {
+		if (!cmd) return undefined;
+
+		if (/\bbd\s+(close|update|create|claim)\b/.test(cmd)) {
 			beadState.lastFetch = 0;
 			setTimeout(() => refreshBeadState().catch(() => {}), 200);
 		}
+		if (/\bgit\s+/.test(cmd)) {
+			runtimeState.lastFetch = 0;
+			setTimeout(() => refreshRuntimeState().catch(() => {}), 200);
+		}
 		return undefined;
 	});
 }

package/config/pi/extensions/quality-gates/index.ts

@@ -1,9 +1,19 @@
-import type { ExtensionAPI, ToolResultEvent } from "@mariozechner/pi-coding-agent";
-import { SubprocessRunner, EventAdapter, Logger } from "../core/lib";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { SubprocessRunner, EventAdapter } from "../core/lib";
 import * as path from "node:path";
 import * as fs from "node:fs";
 
-const logger = new Logger({ namespace: "quality-gates" });
+function resolveQualityHook(cwd: string, ext: string): { runner: string; scriptPath: string } | null {
+	if ([".ts", ".tsx", ".js", ".jsx", ".cjs", ".mjs"].includes(ext)) {
+		const scriptPath = path.join(cwd, ".claude", "hooks", "quality-check.cjs");
+		return { runner: "node", scriptPath };
+	}
+	if (ext === ".py") {
+		const scriptPath = path.join(cwd, ".claude", "hooks", "quality-check.py");
+		return { runner: "python3", scriptPath };
+	}
+	return null;
+}
 
 export default function (pi: ExtensionAPI) {
 	pi.on("tool_result", async (event, ctx) => {
@@ -15,27 +25,17 @@ export default function (pi: ExtensionAPI) {
 
 		const fullPath = path.isAbsolute(filePath) ? filePath : path.join(cwd, filePath);
 		const ext = path.extname(fullPath);
-
-		let scriptPath: string | null = null;
-		let runner: string = "node";
-
-		if ([".ts", ".tsx", ".js", ".jsx"].includes(ext)) {
-			scriptPath = path.join(cwd, ".claude", "hooks", "quality-check.cjs");
-			runner = "node";
-		} else if (ext === ".py") {
-			scriptPath = path.join(cwd, ".claude", "hooks", "quality-check.py");
-			runner = "python3";
-		}
-
-		if (!scriptPath || !fs.existsSync(scriptPath)) return undefined;
+		const resolved = resolveQualityHook(cwd, ext);
+		if (!resolved) return undefined;
+		if (!fs.existsSync(resolved.scriptPath)) return undefined;
 
 		const hookInput = JSON.stringify({
 			tool_name: event.toolName,
 			tool_input: event.input,
-			cwd: cwd,
+			cwd,
 		});
 
-		const result = await SubprocessRunner.run(runner, [scriptPath], {
+		const result = await SubprocessRunner.run(resolved.runner, [resolved.scriptPath], {
 			cwd,
 			input: hookInput,
 			env: { ...process.env, CLAUDE_PROJECT_DIR: cwd },
@@ -43,23 +43,22 @@ export default function (pi: ExtensionAPI) {
 		});
 
 		if (result.code === 0) {
-			if (result.stderr && result.stderr.trim()) {
-				const newContent = [...event.content];
-				newContent.push({ type: "text", text: `\n\n**Quality Gate**: ${result.stderr.trim()}` });
-				return { content: newContent };
-			}
-			return undefined;
+			const details = (result.stdout || result.stderr || "").trim();
+			if (!details) return undefined;
+			return {
+				content: [...event.content, { type: "text", text: `\n\n**Quality Gate**: ${details}` }],
+			};
 		}
 
 		if (result.code === 2) {
-			const newContent = [...event.content];
-			newContent.push({ type: "text", text: `\n\n**Quality Gate FAILED**:\n${result.stderr || result.stdout || "Unknown error"}` });
-			
+			const details = (result.stderr || result.stdout || "Unknown error").trim();
 			if (ctx.hasUI) {
 				ctx.ui.notify(`Quality Gate failed for ${path.basename(fullPath)}`, "error");
 			}
-
-			return { isError: true, content: newContent };
+			return {
+				isError: true,
+				content: [...event.content, { type: "text", text: `\n\n**Quality Gate FAILED**:\n${details}` }],
+			};
 		}
 
 		return undefined;

package/config/pi/extensions/session-flow/index.ts

@@ -14,8 +14,39 @@ function isWorktree(cwd: string): boolean {
 	return cwd.includes("/.xtrm/worktrees/") || cwd.includes("/.claude/worktrees/");
 }
 
+function getSessionId(ctx: any): string {
+	return ctx?.sessionManager?.getSessionId?.() ?? ctx?.sessionId ?? ctx?.session_id ?? process.pid.toString();
+}
+
+async function getSessionClaim(cwd: string, sessionId: string): Promise<string | null> {
+	const claimResult = await SubprocessRunner.run("bd", ["kv", "get", `claimed:${sessionId}`], { cwd });
+	if (claimResult.code !== 0) return null;
+	const claimId = claimResult.stdout.trim();
+	return claimId.length > 0 ? claimId : null;
+}
+
+async function isClaimStillInProgress(cwd: string, issueId: string): Promise<boolean> {
+	const showResult = await SubprocessRunner.run("bd", ["show", issueId, "--json"], { cwd });
+	if (showResult.code === 0 && showResult.stdout.trim()) {
+		try {
+			const parsed = JSON.parse(showResult.stdout);
+			const record = Array.isArray(parsed) ? parsed[0] : parsed;
+			if (record?.status) return record.status === "in_progress";
+		} catch {
+			// fall back to text parsing below
+		}
+	}
+
+	const listResult = await SubprocessRunner.run("bd", ["list", "--status=in_progress"], { cwd });
+	if (listResult.code !== 0) return false;
+	const issuePattern = new RegExp(`^\\s*[◐●]?\\s*${issueId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "m");
+	return issuePattern.test(listResult.stdout);
+}
+
 export default function (pi: ExtensionAPI) {
 	const getCwd = (ctx: any) => ctx.cwd || process.cwd();
+	let lastStopNoticeIssue: string | null = null;
+	let lastWorktreeReminderCwd: string | null = null;
 
 	// Claim sync: notify when a bd update --claim command is run.
 	pi.on("tool_result", async (event, ctx) => {
@@ -31,35 +62,33 @@ export default function (pi: ExtensionAPI) {
 		return { content: [...event.content, { type: "text", text }] };
 	});
 
-	// Stop gate: block agent end if there is an in_progress claimed issue.
-	// Also remind to run `xt end` when session ends inside a worktree.
+	// Stop gate: warn (non-blocking) if this session's claimed issue is still in progress.
+	// IMPORTANT: never call sendUserMessage() from agent_end, it always triggers a new turn.
 	pi.on("agent_end", async (_event, ctx) => {
 		const cwd = getCwd(ctx);
 		if (!EventAdapter.isBeadsProject(cwd)) return undefined;
 
-		const inProgressResult = await SubprocessRunner.run(
-			"bd",
-			["list", "--status=in_progress"],
-			{ cwd },
-		);
-		if (inProgressResult.code === 0 && inProgressResult.stdout) {
-			const output = inProgressResult.stdout;
-			const m = output.match(/Total:\s*\d+\s+issues?\s*\((\d+)\s+open,\s*(\d+)\s+in progress\)/);
-			const inProgressCount = m ? parseInt(m[2], 10) : 0;
-			if (inProgressCount > 0) {
-				const idMatch = output.match(/^\s*([a-zA-Z0-9._-]+)\s+in_progress/m);
-				const issueId = idMatch ? idMatch[1] : "<id>";
-				pi.sendUserMessage(
-					`Stop blocked: close your issue first: bd close ${issueId}`,
-				);
+		const sessionId = getSessionId(ctx);
+		const claimId = await getSessionClaim(cwd, sessionId);
+
+		if (claimId) {
+			const inProgress = await isClaimStillInProgress(cwd, claimId);
+			if (inProgress) {
+				if (lastStopNoticeIssue !== claimId && ctx.hasUI) {
+					ctx.ui.notify(`Stop blocked: close your issue first: bd close ${claimId}`, "warning");
+					lastStopNoticeIssue = claimId;
+				}
 				return undefined;
 			}
+
+			if (lastStopNoticeIssue === claimId) {
+				lastStopNoticeIssue = null;
+			}
 		}
 
-		if (isWorktree(cwd)) {
-			pi.sendUserMessage(
-				"Run `xt end` to create a PR and clean up this worktree.",
-			);
+		if (isWorktree(cwd) && ctx.hasUI && lastWorktreeReminderCwd !== cwd) {
+			ctx.ui.notify("Run `xt end` to create a PR and clean up this worktree.", "info");
+			lastWorktreeReminderCwd = cwd;
 		}
 
 		return undefined;