one-code-extension 0.4.1 → 0.6.0

package/extensions/footer/footer-line.ts

@@ -7,10 +7,13 @@
  * Everything here is pure and paint-injected so it unit-tests with an identity
  * paint. `paint(color, text)` matches `safeThemePaint`; in tests it returns the
  * text unchanged, so assertions see the plain line. Inclusion decisions use
- * plain lengths only, so the painted result (ANSI adds zero display width)
- * always fits the width it was built for.
+ * the plain text's terminal columns (`visibleWidth`, never `.length`, so a CJK
+ * path or branch counts two columns a glyph), so the painted result (ANSI adds
+ * zero display width) always fits the width it was built for.
  */
 
+import { cutPlainText } from "../lib/tui-render.ts";
+import { tailColumns, visibleWidth } from "../lib/text-width.ts";
 import { costOf, usageEntryCost } from "../lib/usage-bus.ts";
 import type { WorktreeLocation } from "../lib/worktree-channel.ts";
 
@@ -21,8 +24,12 @@ export interface FooterData {
 	cwd: string;
 	home: string;
 	branch?: string;
-	/** Context tokens in use and the model's window; both needed to show fill. */
-	contextTokens?: number;
+	/**
+	 * Context tokens in use and the model's window. Tokens are unknown right
+	 * after a compaction until the next reply; the fill then reads `?/window`,
+	 * as pi's own footer shows it.
+	 */
+	contextTokens?: number | null;
 	contextWindow?: number;
 	/** Context percentage, shown in parens after the fill; `null`/undefined omits it
 	 * (e.g. right after compaction, unknown until the next reply). */
@@ -73,12 +80,13 @@ function tilde(cwd: string, home: string): string {
 
 /**
  * Fit a path into `max` columns, keeping the tail (the deepest, most specific
- * folders) with a leading `…`. `max <= 1` collapses to just `…`.
+ * folders) with a leading `…`. `max <= 1` collapses to just `…`. Cut by
+ * columns on a grapheme boundary, so a wide glyph or an emoji stays whole.
  */
 function truncatePath(path: string, max: number): string {
-	if (path.length <= max) return path;
+	if (visibleWidth(path) <= max) return path;
 	if (max <= 1) return "…";
-	return `…${path.slice(path.length - (max - 1))}`;
+	return `…${tailColumns(path, max - 1).text}`;
 }
 
 interface Part {
@@ -86,6 +94,8 @@ interface Part {
 	painted: string;
 	/** Higher drops first when the line is too narrow; 0 = never dropped. */
 	dropPriority: number;
+	/** The model name: the one core part cut (with an ellipsis) when even the core overflows. */
+	model: boolean;
 }
 
 const SEP = " · ";
@@ -103,17 +113,19 @@ export function buildFooterLines(data: FooterData, width: number, paint: Paint):
 	// A labelled metric: the label is muted, the value takes `color`. The plain
 	// form (label + value) drives the width/drop math; the painted form colours
 	// the two halves separately.
-	const push = (label: string, value: string, color: string, dropPriority = 0) => {
+	const push = (label: string, value: string, color: string, dropPriority = 0, model = false) => {
 		if (!value) return;
 		const plain = label ? `${label} ${value}` : value;
 		const painted = label ? `${paint("muted", label)} ${paint(color, value)}` : paint(color, value);
-		parts.push({ plain, painted, dropPriority });
+		parts.push({ plain, painted, dropPriority, model });
 	};
 
-	// Context fill as "usage: tokens/window (pct%)".
-	if (typeof data.contextTokens === "number" && typeof data.contextWindow === "number" && data.contextWindow > 0) {
-		const pct = typeof data.contextPercent === "number" ? ` (${data.contextPercent.toFixed(0)}%)` : "";
-		push("usage:", `${formatTokens(data.contextTokens)}/${formatTokens(data.contextWindow)}${pct}`, "dim");
+	// Context fill as "usage: tokens/window (pct%)", or "?/window" while the
+	// tokens are unknown (right after a compaction).
+	if (typeof data.contextWindow === "number" && data.contextWindow > 0) {
+		const tokens = typeof data.contextTokens === "number" ? formatTokens(data.contextTokens) : "?";
+		const pct = typeof data.contextTokens === "number" && typeof data.contextPercent === "number" ? ` (${data.contextPercent.toFixed(0)}%)` : "";
+		push("usage:", `${tokens}/${formatTokens(data.contextWindow)}${pct}`, "dim");
 	}
 	// Total cost, always shown once known.
 	push("cost:", formatCost(data.cost), "dim");
@@ -123,7 +135,7 @@ export function buildFooterLines(data: FooterData, width: number, paint: Paint):
 		push("cache-hit:", `${data.cacheHitPercent.toFixed(0)}%`, color, 2);
 	}
 	// Model, then effort — no labels; both self-describing.
-	if (data.model) push("", data.model, "dim");
+	if (data.model) push("", data.model, "dim", 0, true);
 	if (data.effort) push("", data.effort, "accent");
 
 	// Left chunk: path + branch, with the open PR attached to the branch as
@@ -132,7 +144,7 @@ export function buildFooterLines(data: FooterData, width: number, paint: Paint):
 	// branch (bare-branch fallback), and only when there is no room even for the
 	// bare branch does the whole chunk go, leaving metrics alone. The three
 	// segments paint separately — path dim, branch in accent, PR in the link
-	// colour — but every width/gap decision uses their plain lengths.
+	// colour — but every width/gap decision uses their plain columns.
 	const path = tilde(data.cwd, data.home);
 	const branchSeg = data.branch ? ` ⎇ ${data.branch}` : "";
 	const prSeg = data.branch && typeof data.pr === "number" ? ` ← PR #${data.pr}` : "";
@@ -140,7 +152,7 @@ export function buildFooterLines(data: FooterData, width: number, paint: Paint):
 	// Drop optional right parts (highest priority first) until the metrics fit.
 	let kept = parts.slice();
 	const rightPlain = () => kept.map((p) => p.plain).join(SEP);
-	while (rightPlain().length > width) {
+	while (visibleWidth(rightPlain()) > width) {
 		const droppable = kept
 			.map((p, i) => ({ p, i }))
 			.filter((x) => x.p.dropPriority > 0)
@@ -149,25 +161,34 @@ export function buildFooterLines(data: FooterData, width: number, paint: Paint):
 		kept = kept.filter((_, i) => i !== droppable.i);
 	}
 
-	const rightLen = rightPlain().length;
-
-	// Even the core overflows: last resort, truncate the plain metrics to width.
-	if (rightLen > width) {
-		return [paint("dim", rightPlain().slice(0, width))];
+	// Even the core overflows: cut the model name with an ellipsis so the
+	// effort after it stays; when that is not enough, cut the whole line.
+	const overflow = visibleWidth(rightPlain()) - width;
+	if (overflow > 0) {
+		const model = kept.find((p) => p.model);
+		const room = model ? visibleWidth(model.plain) - overflow : 0;
+		if (model && room >= 4) {
+			const shortened = cutPlainText(model.plain, room);
+			kept = kept.map((p) => (p === model ? { ...p, plain: shortened, painted: paint("dim", shortened) } : p));
+		} else {
+			return [paint("dim", cutPlainText(rightPlain(), width))];
+		}
 	}
 
+	const rightLen = visibleWidth(rightPlain());
+
 	const rightPaintedStr = kept.map((p) => p.painted).join(paint("dim", SEP));
 
 	// Room for the left chunk after the metrics and at least one space of gap.
 	// Keep the PR only if the branch+PR both fit; otherwise drop it and keep the
 	// bare branch.
 	const room = width - rightLen - 1;
-	const keptPr = room >= branchSeg.length + prSeg.length + 1 ? prSeg : "";
-	const suffixLen = branchSeg.length + keptPr.length;
+	const keptPr = room >= visibleWidth(branchSeg) + visibleWidth(prSeg) + 1 ? prSeg : "";
+	const suffixLen = visibleWidth(branchSeg) + visibleWidth(keptPr);
 	if (room >= suffixLen + 1) {
 		const shownPath = truncatePath(path, room - suffixLen);
 		const leftPlain = `${shownPath}${branchSeg}${keptPr}`;
-		const gap = " ".repeat(width - leftPlain.length - rightLen);
+		const gap = " ".repeat(Math.max(0, width - visibleWidth(leftPlain) - rightLen));
 		const leftPainted = `${paint("dim", shownPath)}${paint("accent", branchSeg)}${paint("mdLink", keptPr)}`;
 		return [`${leftPainted}${gap}${rightPaintedStr}`];
 	}

package/extensions/footer/index.ts

@@ -24,7 +24,7 @@ import { ULTRACODE_STATUS_KEY } from "../effort/slider.ts";
 import { USAGE_CHANNEL } from "../lib/usage-bus.ts";
 import { buildFooterLines, computeMainUsage, footerLocation, type FooterData } from "./footer-line.ts";
 import { WORKTREE_CHANNEL, type WorktreeLocation } from "../lib/worktree-channel.ts";
-import { fetchPrNumber } from "./pr.ts";
+import { fetchPrNumber, nextPrPollDelay, PR_SLOW_LOOKUP_MS } from "./pr.ts";
 
 export default function footerExtension(pi: ExtensionAPI) {
 	if (process.env.CC_FOOTER === "0") return;
@@ -38,6 +38,27 @@ export default function footerExtension(pi: ExtensionAPI) {
 	let pr: number | undefined;
 	/** Bumped per branch change so a slow gh lookup for an old branch is ignored. */
 	let prToken = 0;
+	/**
+	 * The PR is looked up again once a minute while the session is in use, so a
+	 * PR merged or closed mid-session disappears (pr.ts nextPrPollDelay). A slow
+	 * or missing `gh` turns polling off; branch changes still look up.
+	 */
+	const prPoll = { lastLookupAt: 0, lastInputAt: Date.now(), disabled: false };
+	let prPollTimer: ReturnType<typeof setTimeout> | undefined;
+	const stopPrPoll = () => {
+		clearTimeout(prPollTimer);
+		prPollTimer = undefined;
+	};
+	const schedulePrPoll = () => {
+		stopPrPoll();
+		const delay = nextPrPollDelay(prPoll, Date.now());
+		if (delay === undefined) return;
+		prPollTimer = setTimeout(() => {
+			prPollTimer = undefined;
+			refreshLocation();
+		}, delay);
+		prPollTimer.unref?.();
+	};
 
 	/** Invalidate the memoized line and repaint; set once the footer mounts. */
 	let repaint = () => {};
@@ -71,20 +92,43 @@ export default function footerExtension(pi: ExtensionAPI) {
 
 	const refreshPr = (cwd: string, branch: string | null) => {
 		const token = ++prToken;
+		stopPrPoll();
 		if (!branch) {
 			pr = undefined;
 			repaint();
 			return;
 		}
+		const startedAt = Date.now();
+		prPoll.lastLookupAt = startedAt;
 		void fetchPrNumber(cwd, branch).then((found) => {
 			if (token !== prToken) return; // a newer branch superseded this lookup
-			pr = found;
+			if (found.ghMissing || Date.now() - startedAt > PR_SLOW_LOOKUP_MS) prPoll.disabled = true;
+			pr = found.pr;
 			repaint();
+			schedulePrPoll();
 		});
 	};
 
+	// Input keeps polling alive; after an hour without any, the next input
+	// resumes it. A turn boundary asks again, never sooner than a minute after
+	// the last lookup.
+	pi.on("input", () => {
+		prPoll.lastInputAt = Date.now();
+		if (!prPollTimer) schedulePrPoll();
+	});
+	pi.on("agent_settled", () => {
+		if (!prPollTimer) schedulePrPoll();
+	});
+	pi.on("session_shutdown", () => {
+		stopPrPoll();
+		prToken++;
+	});
+
 	pi.on("session_start", (_event, ctx) => {
 		recomputeMain(ctx);
+		// A slow or missing gh turns polling off for one session, not the process.
+		prPoll.disabled = false;
+		prPoll.lastInputAt = Date.now();
 		if (!ctx.hasUI) return;
 
 		ctx.ui.setFooter((tui: unknown, theme: unknown, footerData: unknown) => {
@@ -144,6 +188,7 @@ export default function footerExtension(pi: ExtensionAPI) {
 			return Object.assign(component, {
 				dispose: () => {
 					stopFollowingBranch();
+					stopPrPoll();
 					repaint = () => {};
 					refreshLocation = () => {};
 				},

package/extensions/footer/pr.ts

@@ -8,7 +8,9 @@
  * a PR whose head lives in the base repo, so it misses the common case of a PR
  * opened from a fork (`isCrossRepository`), even though `list` on the base repo
  * knows about it. `--state open` keeps a merged/closed PR for the same branch
- * name from showing.
+ * name from showing. The footer repeats the lookup once a minute while the
+ * session is in use (`nextPrPollDelay`), so a PR merged, closed or opened
+ * mid-session shows within a minute.
  *
  * The exec lives here but the parse is split out so it unit-tests without a
  * subprocess.
@@ -35,19 +37,46 @@ export function parsePrNumber(stdout: string): number | undefined {
 
 const LOOKUP_TIMEOUT_MS = 4000;
 
+/** A lookup's outcome: the open PR, if any, and whether `gh` is not installed at all. */
+export interface PrLookup {
+	pr: number | undefined;
+	ghMissing: boolean;
+}
+
 /**
- * Resolve the open PR number for `branch` in `cwd`, or `undefined`. Never
- * rejects: any failure (no gh, no PR, detached HEAD, timeout) is `undefined`.
+ * Resolve the open PR number for `branch` in `cwd`. Never rejects: any failure
+ * (no gh, no PR, detached HEAD, timeout) has `pr` undefined, and a `gh` that
+ * is not on PATH says so, so the footer stops polling for it.
  */
-export function fetchPrNumber(cwd: string, branch: string): Promise<number | undefined> {
+export function fetchPrNumber(cwd: string, branch: string): Promise<PrLookup> {
 	return new Promise((resolve) => {
 		execFile(
 			"gh",
 			["pr", "list", "--head", branch, "--state", "open", "--json", "number"],
 			{ cwd, timeout: LOOKUP_TIMEOUT_MS, encoding: "utf8" },
 			(error, stdout) => {
-				resolve(error ? undefined : parsePrNumber(stdout));
+				const ghMissing = (error as NodeJS.ErrnoException | null)?.code === "ENOENT";
+				resolve({ pr: error ? undefined : parsePrNumber(stdout), ghMissing });
 			},
 		);
 	});
 }
+
+/** Claude Code's PR status cadence (its `usePrStatus`): one lookup a minute while the session is in use. */
+export const PR_POLL_INTERVAL_MS = 60_000;
+/** Polling stops after this long without user input, and resumes on the next input. */
+export const PR_IDLE_STOP_MS = 60 * 60_000;
+/** A lookup slower than this turns polling off for the session (branch changes still look up). */
+export const PR_SLOW_LOOKUP_MS = 4_000;
+
+/**
+ * When the next PR lookup is due, relative to the last one: never sooner than
+ * PR_POLL_INTERVAL_MS after it, so a turn boundary asking for a refresh does
+ * not spawn `gh` more than once a minute. Undefined when polling should stop:
+ * turned off by a slow lookup, or no input for PR_IDLE_STOP_MS.
+ */
+export function nextPrPollDelay(state: { lastLookupAt: number; lastInputAt: number; disabled: boolean }, now: number): number | undefined {
+	if (state.disabled) return undefined;
+	if (now - state.lastInputAt >= PR_IDLE_STOP_MS) return undefined;
+	return Math.max(0, state.lastLookupAt + PR_POLL_INTERVAL_MS - now);
+}

package/extensions/hooks/compaction.ts

@@ -0,0 +1,7 @@
+/** Successful PreCompact hook output, scoped to the compaction that requested it. */
+export const PRECOMPACT_INSTRUCTIONS_CHANNEL = "one-code:precompact-instructions";
+
+export interface PreCompactInstructions {
+	signal: AbortSignal;
+	instructions: string;
+}

package/extensions/hooks/executor.ts

@@ -7,7 +7,7 @@
  * pi.exec is deliberately not used: it hardcodes shell:false and gives the
  * child no stdin, while Claude Code hooks are shell command strings that read
  * a JSON payload from stdin. (Ported from pi-code's runHookCommand, MIT — see
- * docs/decisions.md.)
+ * working-docs/decisions.md.)
  *
  * The interpreter is Claude Code's: bash (Git Bash on Windows, honouring
  * `CLAUDE_CODE_GIT_BASH_PATH`) unless the hook says `shell: "powershell"`, or
@@ -22,7 +22,8 @@
  *   otherwise `close` never fires and the promise hangs past the timeout
  *   (Windows: `taskkill /T /F` on the leader's pid does the same)
  * - setEncoding("utf8") so multi-byte characters can't be split across chunks
- * - output capped at 1MB per stream
+ * - a hook exceeding 1MB per stream is killed and reported as an output-limit
+ *   failure, never parsed as a silently truncated JSON verdict
  * - stdin errors ignored (a hook that exits without reading stdin — `exit 2`
  *   — would otherwise EPIPE-crash the write)
  * - stdin JSON is newline-terminated: without a trailing "\n" a hook doing
@@ -41,13 +42,14 @@
  *   SIGCHLD-driven exit callback; with the process handle unref'd the loop
  *   counted itself empty and node exited 0 mid-tool, silently, before the
  *   hook's `close` ever fired — measured at ~55% of runs with a trivial
- *   `exit 0` hook (docs/one-shot-lsp-event-loop-drain.md has the same
+ *   `exit 0` hook (working-docs/one-shot-lsp-event-loop-drain.md has the same
  *   mechanism for the LSP client). A ref'd child holds the loop until `close`.
  */
 
 import type { ChildProcess } from "node:child_process";
 import { detachedSpawnOptions, killProcessTree, waitForChildExit } from "../lib/process-tree.ts";
 import { bashSpawn, POWERSHELL_UTF8_PREFIX, powerShellSpawn, type ShellSpawn, spawnShellCommand } from "../lib/shell-spawn.ts";
+import type { FinishedRun } from "./protocol.ts";
 import type { HookShell } from "./settings.ts";
 
 /**
@@ -76,29 +78,12 @@ export function hookShellSpawn(shell: HookShell | undefined): { spec?: ShellSpaw
 	return { spec: resolved.spawn, shell: want };
 }
 
-export interface HookRunResult {
-	/**
-	 * null when the process was killed (timeout) or never spawned. Normalized on
-	 * the timeout path rather than taken from `waitpid`: a group SIGKILL is not
-	 * atomic, so the shell can be scheduled after its foreground child is killed
-	 * and before its own signal lands, reap the child and exit(128+9) itself —
-	 * `close` then reports a normal exit of 137 instead of death by signal
-	 * (roughly 1% of timeouts under load, and never when the shell had exec'd
-	 * away, leaving no shell to reap; findings §10.20). Callers should still
-	 * prefer `timedOut`, which says what happened rather than what it looked
-	 * like, but they no longer have to.
-	 */
-	exitCode: number | null;
-	timedOut: boolean;
-	/** Set when the child could not be spawned at all. */
-	spawnError?: string;
-	stdout: string;
-	stderr: string;
-	durationMs: number;
-}
+/** A finished run (`protocol.ts FinishedRun`, field docs there) and how long it took. */
+export type HookRunResult = FinishedRun & { durationMs: number };
 
 export interface HookRunOptions {
 	cwd: string;
+	signal?: AbortSignal;
 	/** Seconds, Claude Code convention. Clamped to [1, MAX_TIMEOUT_S]. */
 	timeoutSeconds?: number;
 	/** Exposed to the hook as CLAUDE_PROJECT_DIR; defaults to cwd. */
@@ -129,6 +114,10 @@ export function runHookCommand(command: string, stdinJson: string, opts: HookRun
 	const started = Date.now();
 
 	return new Promise((resolve) => {
+		if (opts.signal?.aborted) {
+			resolve({ exitCode: null, timedOut: false, aborted: true, stdout: "", stderr: "", durationMs: Date.now() - started });
+			return;
+		}
 		let child: ChildProcess;
 		const failed = (spawnError: string) =>
 			resolve({ exitCode: null, timedOut: false, spawnError, stdout: "", stderr: "", durationMs: Date.now() - started });
@@ -175,14 +164,26 @@ export function runHookCommand(command: string, stdinJson: string, opts: HookRun
 		let stdout = "";
 		let stderr = "";
 		let timedOut = false;
+		let aborted = false;
+		let outputLimitExceeded = false;
+		const outputBytes = { stdout: 0, stderr: 0 };
 		let settled = false;
+		const onAbort = () => {
+			aborted = true;
+			killProcessTree(child, "SIGKILL");
+		};
+		opts.signal?.addEventListener("abort", onAbort, { once: true });
 
 		const capture = (sink: "stdout" | "stderr") => (chunk: string) => {
-			const current = sink === "stdout" ? stdout : stderr;
-			if (current.length >= MAX_OUTPUT_BYTES) return;
-			const next = current + chunk.slice(0, MAX_OUTPUT_BYTES - current.length);
-			if (sink === "stdout") stdout = next;
-			else stderr = next;
+			if (outputLimitExceeded) return;
+			outputBytes[sink] += Buffer.byteLength(chunk, "utf8");
+			if (outputBytes[sink] > MAX_OUTPUT_BYTES) {
+				outputLimitExceeded = true;
+				killProcessTree(child, "SIGKILL");
+				return;
+			}
+			if (sink === "stdout") stdout += chunk;
+			else stderr += chunk;
 		};
 		child.stdout?.setEncoding("utf8");
 		child.stderr?.setEncoding("utf8");
@@ -200,7 +201,8 @@ export function runHookCommand(command: string, stdinJson: string, opts: HookRun
 			if (settled) return;
 			settled = true;
 			clearTimeout(timer);
-			resolve({ ...result, durationMs: Date.now() - started });
+			opts.signal?.removeEventListener("abort", onAbort);
+			resolve({ ...result, ...(aborted ? { aborted: true } : {}), ...(outputLimitExceeded ? { outputLimitExceeded: true } : {}), durationMs: Date.now() - started });
 		};
 
 		// Settles on exit plus a short stdio grace, not on `close`: a grandchild
@@ -211,7 +213,7 @@ export function runHookCommand(command: string, stdinJson: string, opts: HookRun
 		// keeps "we killed it" from ever looking like an ordinary non-zero exit,
 		// which fails OPEN downstream.
 		waitForChildExit(child).then(
-			({ code }) => finish({ exitCode: timedOut ? null : code, timedOut, stdout, stderr }),
+			({ code }) => finish({ exitCode: timedOut || aborted || outputLimitExceeded ? null : code, timedOut, stdout, stderr }),
 			(error: Error) => finish({ exitCode: null, timedOut, spawnError: error.message, stdout, stderr }),
 		);