@oh-my-pi/pi-coding-agent 15.10.0 → 15.10.2

package/src/tools/gh-cache-invalidation.ts

@@ -0,0 +1,200 @@
+/**
+ * Detect cache-mutating `gh` subcommands inside a bash invocation and drop
+ * the matching `github-cache` rows so a subsequent `issue://<n>` or
+ * `pr://<n>` read sees the post-mutation state instead of the stale
+ * pre-mutation snapshot.
+ *
+ * Triggered before the bash command runs: on success the cache is now
+ * empty and the next read fetches fresh; on failure the worst case is one
+ * extra `gh` round-trip on the following read. That cost is bounded and
+ * eliminates the much-worse "issue shows OPEN for up to softTtlSec after
+ * `gh issue close`" failure mode reported by users.
+ *
+ * Detector scope: ops that change visible issue/PR state — `close`,
+ * `reopen`, `merge`, `delete`, `ready`, `lock`, `unlock`, `pin`, `unpin`,
+ * `transfer`, plus the comment/review/edit ops that change the rendered
+ * body. We deliberately over-invalidate (e.g. all matching rows for the
+ * number, all auth_keys) because the upside of staleness elimination
+ * dwarfs the cost of one cache miss.
+ */
+import { invalidateAllForNumber } from "./github-cache";
+
+const PR_URL_PATTERN = /^https:\/\/github\.com\/([^/\s]+\/[^/\s]+)\/pull\/(\d+)(?:[/?#].*)?$/i;
+const ISSUE_URL_PATTERN = /^https:\/\/github\.com\/([^/\s]+\/[^/\s]+)\/issues\/(\d+)(?:[/?#].*)?$/i;
+
+/** Subcommands that mutate the rendered issue/PR view in any meaningful way. */
+const MUTATING_ISSUE_SUBCMDS: Record<string, true> = {
+	close: true,
+	reopen: true,
+	delete: true,
+	edit: true,
+	comment: true,
+	lock: true,
+	unlock: true,
+	pin: true,
+	unpin: true,
+	transfer: true,
+	develop: true,
+};
+
+const MUTATING_PR_SUBCMDS: Record<string, true> = {
+	close: true,
+	reopen: true,
+	merge: true,
+	ready: true,
+	edit: true,
+	comment: true,
+	review: true,
+	lock: true,
+	unlock: true,
+};
+/**
+ * Walk a single shell command's token stream looking for a top-level
+ * `gh (issue|pr) <subcmd> <id-or-url>` invocation and return the
+ * invalidation key when one is found. Returns `null` for non-matching
+ * commands so the caller can iterate cheaply.
+ */
+function detectGhMutation(tokens: readonly string[]): { number: number; repo?: string } | null {
+	const ghIdx = tokens.indexOf("gh");
+	if (ghIdx === -1) return null;
+	const subject = tokens[ghIdx + 1];
+	if (subject !== "issue" && subject !== "pr") return null;
+	const subcmd = tokens[ghIdx + 2];
+	if (!subcmd) return null;
+	const expected = subject === "issue" ? MUTATING_ISSUE_SUBCMDS : MUTATING_PR_SUBCMDS;
+	if (!expected[subcmd]) return null;
+
+	let repo: string | undefined;
+	// First pass: scan for --repo so it wins regardless of position relative
+	// to the issue/PR identifier (gh accepts the flag both before and after
+	// the positional argument).
+	for (let i = ghIdx + 3; i < tokens.length; i++) {
+		const token = tokens[i];
+		if (token === "-R" || token === "--repo") {
+			const next = tokens[i + 1];
+			if (next) repo = next;
+			i++;
+			continue;
+		}
+		if (token.startsWith("--repo=")) {
+			repo = token.slice("--repo=".length);
+		}
+	}
+	for (let i = ghIdx + 3; i < tokens.length; i++) {
+		const token = tokens[i];
+		if (token === "-R" || token === "--repo") {
+			i++;
+			continue;
+		}
+		if (token.startsWith("-")) continue;
+		const direct = /^\d+$/.test(token) ? Number(token) : undefined;
+		if (direct !== undefined && Number.isSafeInteger(direct) && direct > 0) {
+			return repo !== undefined ? { number: direct, repo } : { number: direct };
+		}
+		const urlMatch = (subject === "pr" ? PR_URL_PATTERN : ISSUE_URL_PATTERN).exec(token);
+		if (urlMatch) {
+			const num = Number(urlMatch[2]);
+			if (Number.isSafeInteger(num) && num > 0) {
+				// URL carries its own repo and wins over a stray --repo flag.
+				return { number: num, repo: urlMatch[1] };
+			}
+		}
+	}
+	return null;
+}
+
+/**
+ * Conservative tokenizer that splits a bash command into individual word
+ * tokens. Handles single/double-quoted strings, backslash escapes, and
+ * standard operators (`;`, `&&`, `||`, `|`, `&`, newlines) as token
+ * boundaries that emit a sentinel `";"` so the caller treats the segments
+ * as independent command sequences. We do not attempt full POSIX shell
+ * parsing — heredocs, command substitution, and arithmetic expansion are
+ * out of scope; the detector simply falls through when it cannot find a
+ * clean `gh issue|pr <subcmd>` triple.
+ */
+function tokenize(command: string): string[][] {
+	const segments: string[][] = [];
+	let current: string[] = [];
+	let buffer = "";
+	let inSingle = false;
+	let inDouble = false;
+	const pushBuffer = () => {
+		if (buffer.length > 0) {
+			current.push(buffer);
+			buffer = "";
+		}
+	};
+	const pushSegment = () => {
+		pushBuffer();
+		if (current.length > 0) segments.push(current);
+		current = [];
+	};
+	for (let i = 0; i < command.length; i++) {
+		const ch = command[i];
+		if (inSingle) {
+			if (ch === "'") {
+				inSingle = false;
+				continue;
+			}
+			buffer += ch;
+			continue;
+		}
+		if (inDouble) {
+			if (ch === "\\" && i + 1 < command.length) {
+				const next = command[i + 1];
+				if (next === '"' || next === "\\" || next === "$" || next === "`") {
+					buffer += next;
+					i++;
+					continue;
+				}
+			}
+			if (ch === '"') {
+				inDouble = false;
+				continue;
+			}
+			buffer += ch;
+			continue;
+		}
+		if (ch === "'") {
+			inSingle = true;
+			continue;
+		}
+		if (ch === '"') {
+			inDouble = true;
+			continue;
+		}
+		if (ch === "\\" && i + 1 < command.length) {
+			buffer += command[i + 1];
+			i++;
+			continue;
+		}
+		if (ch === " " || ch === "\t") {
+			pushBuffer();
+			continue;
+		}
+		if (ch === "\n" || ch === ";" || ch === "&" || ch === "|" || ch === "(" || ch === ")") {
+			pushSegment();
+			// `&&`, `||` already collapsed by the segment break above.
+			continue;
+		}
+		buffer += ch;
+	}
+	pushSegment();
+	return segments;
+}
+
+/**
+ * Drop `github-cache` rows for any `gh issue|pr <mutating-subcmd>` call
+ * embedded in `command`. Safe to invoke unconditionally; no-op when the
+ * command does not touch GitHub state.
+ */
+export function invalidateGithubCacheForBashCommand(command: string): void {
+	if (!command?.includes("gh")) return;
+	const segments = tokenize(command);
+	for (const segment of segments) {
+		const hit = detectGhMutation(segment);
+		if (!hit) continue;
+		invalidateAllForNumber(hit.number, hit.repo);
+	}
+}

package/src/tools/gh-renderer.ts

@@ -1,7 +1,7 @@
-import { type Component, padding, Text, truncateToWidth, visibleWidth } from "@oh-my-pi/pi-tui";
+import { type Component, padding, Text, visibleWidth } from "@oh-my-pi/pi-tui";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme, ThemeColor } from "../modes/theme/theme";
-import { renderStatusLine } from "../tui";
+import { framedBlock, renderStatusLine } from "../tui";
 import type {
 	GhRunWatchFailedLogDetails,
 	GhRunWatchJobDetails,
@@ -239,7 +239,7 @@ function renderFailedLogs(
 		return [];
 	}
 
-	const lines = ["", theme.fg("error", "failed logs")];
+	const lines: string[] = [];
 	for (const entry of failedLogs) {
 		const context = entry.workflowName ? `${entry.workflowName}  #${entry.runId}` : `run #${entry.runId}`;
 		lines.push(
@@ -268,36 +268,45 @@ function renderFailedLogs(
 	return lines;
 }
 
-function buildWatchLines(
+function buildWatchSections(
 	watch: GhRunWatchViewDetails,
 	theme: Theme,
 	options: RenderResultOptions,
 	width: number,
-): string[] {
-	const lines = [theme.fg("muted", getWatchHeader(watch))];
+): Array<{ label?: string; lines: string[] }> {
+	const main: string[] = [];
 
 	if (watch.note) {
-		lines.push(theme.fg("dim", replaceTabs(watch.note)));
+		main.push(theme.fg("dim", replaceTabs(watch.note)));
 	}
 
 	if (watch.mode === "run" && watch.run) {
-		lines.push(...renderRunBlock(watch.run, width, theme));
+		main.push(...renderRunBlock(watch.run, width, theme));
 	} else if (watch.mode === "commit") {
 		const runs = watch.runs ?? [];
 		if (runs.length === 0) {
-			lines.push(theme.fg("dim", "waiting for workflow runs..."));
+			main.push(theme.fg("dim", "waiting for workflow runs..."));
 		} else {
 			runs.forEach((run, index) => {
 				if (index > 0) {
-					lines.push("");
+					main.push("");
 				}
-				lines.push(...renderRunBlock(run, width, theme));
+				main.push(...renderRunBlock(run, width, theme));
 			});
 		}
 	}
 
-	lines.push(...renderFailedLogs(watch.failedLogs ?? [], width, theme, options.expanded));
-	return lines;
+	const sections: Array<{ label?: string; lines: string[] }> = [];
+	if (main.length > 0) {
+		sections.push({ lines: main });
+	}
+
+	const failed = renderFailedLogs(watch.failedLogs ?? [], width, theme, options.expanded);
+	if (failed.length > 0) {
+		sections.push({ label: "failed logs", lines: failed });
+	}
+
+	return sections;
 }
 
 function extractText(content: Array<{ type: string; text?: string }>): string {
@@ -335,29 +344,44 @@ function renderFallbackComponent(
 	}
 
 	const allLines = replaceTabs(text).split("\n");
+	while (allLines.length > 0 && allLines[0].trim() === "") allLines.shift();
+	while (allLines.length > 0 && allLines[allLines.length - 1].trim() === "") allLines.pop();
+
+	// Trivial one-line *success* result: a clean status line beats an almost-empty box.
+	// Errors always frame so the message reads as a structured block, never a raw red wrap.
+	if (allLines.length <= 1 && !isError) {
+		const body = allLines[0];
+		if (!body) return new Text(header, 0, 0);
+		const colored = isError ? theme.fg("error", body) : theme.fg("toolOutput", body);
+		return new Text(`${header}\n${colored}`, 0, 0);
+	}
 
-	return {
-		render(width: number): string[] {
-			const lineWidth = Math.max(24, width || FALLBACK_WIDTH);
-			const expanded = options.expanded;
-			const limit = expanded ? allLines.length : Math.min(allLines.length, PREVIEW_LIMITS.OUTPUT_EXPANDED);
-			const visible = allLines.slice(0, limit);
-			const remaining = allLines.length - visible.length;
-
-			const out: string[] = [header];
-			for (const line of visible) {
-				const colored = isError ? theme.fg("error", line) : theme.fg("toolOutput", line);
-				out.push(truncateVisualWidth(colored, lineWidth));
-			}
-			if (!expanded && remaining > 0) {
-				const hint = formatExpandHint(theme, expanded, true);
-				const more = `${formatMoreItems(remaining, "line")}${hint ? ` ${hint}` : ""}`;
-				out.push(theme.fg("dim", more));
-			}
-			return out.map(line => truncateToWidth(line, lineWidth));
-		},
-		invalidate() {},
-	};
+	return framedBlock(theme, width => {
+		const lineWidth = Math.max(1, (width || FALLBACK_WIDTH) - 3);
+		const expanded = options.expanded;
+		const limit = expanded ? allLines.length : Math.min(allLines.length, PREVIEW_LIMITS.OUTPUT_EXPANDED);
+		const visible = allLines.slice(0, limit);
+		const remaining = allLines.length - visible.length;
+
+		const out: string[] = [];
+		for (const line of visible) {
+			const colored = isError ? theme.fg("error", line) : theme.fg("toolOutput", line);
+			out.push(truncateVisualWidth(colored, lineWidth));
+		}
+		if (!expanded && remaining > 0) {
+			const hint = formatExpandHint(theme, expanded, true);
+			const more = `${formatMoreItems(remaining, "line")}${hint ? ` ${hint}` : ""}`;
+			out.push(theme.fg("dim", more));
+		}
+		return {
+			header,
+			sections: out.length > 0 ? [{ lines: out }] : [],
+			state: isError ? "error" : "success",
+			borderColor: isError ? "error" : "borderMuted",
+			applyBg: false,
+			width,
+		};
+	});
 }
 
 function renderWatchCall(args: GithubToolRenderArgs, options: RenderResultOptions, theme: Theme): Component {
@@ -380,7 +404,7 @@ function renderWatchCall(args: GithubToolRenderArgs, options: RenderResultOption
 	}
 
 	const header = `${icon} ${titleText}  ${metaText}`;
-	const wait = theme.fg("dim", "  waiting for workflow data...");
+	const wait = theme.fg("dim", "waiting for workflow data...");
 	return new Text(`${header}\n${wait}`, 0, 0);
 }
 
@@ -412,13 +436,28 @@ export const githubToolRenderer = {
 	): Component {
 		const watch = result.details?.watch;
 		if (watch) {
-			return {
-				render(width: number): string[] {
-					const lineWidth = Math.max(24, width || FALLBACK_WIDTH);
-					return buildWatchLines(watch, uiTheme, options, lineWidth).map(line => truncateToWidth(line, lineWidth));
+			const isError = result.isError === true;
+			const header = renderStatusLine(
+				{
+					icon: isError ? "error" : "success",
+					title: "GitHub Run Watch",
+					titleColor: isError ? "error" : "accent",
+					meta: [getWatchHeader(watch)],
 				},
-				invalidate() {},
-			};
+				uiTheme,
+			);
+			return framedBlock(uiTheme, width => {
+				const innerWidth = Math.max(1, (width || FALLBACK_WIDTH) - 3);
+				const sections = buildWatchSections(watch, uiTheme, options, innerWidth);
+				return {
+					header,
+					sections,
+					state: isError ? "error" : "success",
+					borderColor: isError ? "error" : "borderMuted",
+					applyBg: false,
+					width,
+				};
+			});
 		}
 
 		return renderFallbackComponent(result, options, uiTheme, args ?? {});

package/src/tools/github-cache.ts

@@ -316,6 +316,31 @@ export function invalidate(
 	}
 }
 
+/**
+ * Drop every cached row for a given issue/PR number, regardless of repo,
+ * auth key, include_comments flag, or row kind ({@link CacheKind}). Best-effort:
+ * swallows DB failures the same way {@link invalidate} does.
+ *
+ * Used by the bash-side detector that reacts to `gh issue close` / `gh pr merge`
+ * style mutations. Repo + auth-key narrowing is intentionally skipped because
+ * the bash command often does not name the repo (defaults to cwd's `gh`
+ * config) and resolving the *current* repo from `cwd` for every bash call would
+ * be far more expensive than a write-amplified DELETE.
+ */
+export function invalidateAllForNumber(number: number, repo?: string): void {
+	const db = openDb();
+	if (!db) return;
+	try {
+		if (repo === undefined) {
+			db.prepare("DELETE FROM github_view_cache WHERE number = ?").run(number);
+		} else {
+			db.prepare("DELETE FROM github_view_cache WHERE number = ? AND repo = ?").run(number, normalizeRepo(repo));
+		}
+	} catch (err) {
+		logger.debug("github cache: invalidateAllForNumber failed", { err: String(err) });
+	}
+}
+
 /** Drop every cached row. Test helper. */
 export function clearAll(): void {
 	const db = openDb();