one-code-extension 0.4.1 → 0.5.0

package/extensions/send-now/index.ts

@@ -0,0 +1,133 @@
+/**
+ * send-now extension — Claude Code's "send now" for messages queued mid-turn.
+ *
+ * A message typed while a turn runs waits in pi's queue until the current
+ * response and its tool calls finish. `ctrl+x ctrl+s` (chord.ts) delivers it
+ * at once: the running turn is aborted, which makes pi move every queued
+ * message and the draft back into the editor (its abort handler), and once the
+ * session is idle that text is sent as the next prompt (a pasted image is its
+ * file path in the text, so nothing is lost). Running tools are cancelled, as in Claude Code before 2.1.283, which moves
+ * them to the background instead. A dim `ctrl+x ctrl+s to send now` line sits
+ * above the editor while anything is queued.
+ *
+ * pi binds `ctrl+x` alone to copy; while send now applies, `ctrl+x` is only the
+ * chord's prefix (chord.ts), and one the chord does not complete (another key,
+ * or CHORD_TIMEOUT_MS without one) is dropped. Only public extension API.
+ *
+ * pi exposes no read of its queue to extensions, only `hasPendingMessages()`,
+ * so the hint asks on every render rather than tracking queue events (a
+ * dequeue with alt+up fires none). TUI only.
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { SEND_NOW_CHANNEL } from "../lib/send-now-channel.ts";
+import { safeThemePaint, truncateLine } from "../lib/tui-render.ts";
+import { SEND_NOW_HINT, SendNowChord } from "./chord.ts";
+
+/** How long send now waits for the aborted turn to settle before giving up. */
+const IDLE_WAIT_MS = 10_000;
+/** How long a held `ctrl+x` waits for its `ctrl+s` before the chord is dropped. */
+const CHORD_TIMEOUT_MS = 1_000;
+
+export default function sendNowExtension(pi: ExtensionAPI) {
+	let unsubscribe: (() => void) | undefined;
+	// Bumped on every session start and shutdown, so a send now still waiting
+	// for the aborted turn never acts on a replaced or closed session.
+	let epoch = 0;
+	/** Resolves a send now waiting for the aborted turn to settle. */
+	let onSettled: (() => void) | undefined;
+	const wakeSettled = () => {
+		const wake = onSettled;
+		onSettled = undefined;
+		wake?.();
+	};
+	pi.on("agent_settled", wakeSettled);
+
+	pi.on("session_shutdown", () => {
+		epoch++;
+		wakeSettled();
+		unsubscribe?.();
+		unsubscribe = undefined;
+	});
+
+	pi.on("session_start", (_event, ctx) => {
+		unsubscribe?.();
+		unsubscribe = undefined;
+		const session = ++epoch;
+		const current = () => epoch === session;
+		if (!ctx.hasUI || ctx.mode !== "tui") return;
+
+		const queued = () => !ctx.isIdle() && ctx.hasPendingMessages();
+		// Claude Code sends the draft too, so a draft alone is enough to send now.
+		const active = () => !ctx.isIdle() && (ctx.hasPendingMessages() || ctx.ui.getEditorText().trim() !== "");
+
+		let sending = false;
+		const sendNow = async (turnCtx: ExtensionContext) => {
+			if (sending) return;
+			sending = true;
+			try {
+				pi.events.emit(SEND_NOW_CHANNEL, {});
+				turnCtx.abort();
+				if (!turnCtx.isIdle()) {
+					await new Promise<void>((resolve) => {
+						const fallback = setTimeout(resolve, IDLE_WAIT_MS);
+						fallback.unref?.();
+						onSettled = () => {
+							clearTimeout(fallback);
+							resolve();
+						};
+					});
+				}
+				if (!current() || !turnCtx.isIdle()) return;
+				const text = turnCtx.ui.getEditorText().trim();
+				if (!text) return;
+				turnCtx.ui.setEditorText("");
+				// followUp: an async UserPromptSubmit hook runs before pi's busy
+				// check, and on pi 1.2.0 a run starting meanwhile would reject a
+				// bare send after the editor was cleared.
+				pi.sendUserMessage(text, { deliverAs: "followUp" });
+			} finally {
+				sending = false;
+			}
+		};
+
+		const chord = new SendNowChord();
+		let timer: ReturnType<typeof setTimeout> | undefined;
+		const stopUnsubscribe = ctx.ui.onTerminalInput((data) => {
+			clearTimeout(timer);
+			switch (chord.feed(data, active())) {
+				case "hold":
+					timer = setTimeout(() => chord.expire(), CHORD_TIMEOUT_MS);
+					timer.unref?.();
+					return { consume: true };
+				case "send":
+					void sendNow(ctx);
+					return { consume: true };
+				default:
+					return undefined;
+			}
+		});
+		unsubscribe = () => {
+			clearTimeout(timer);
+			stopUnsubscribe();
+		};
+
+		ctx.ui.setWidget("send-now", (_tui, theme) => {
+			const paint = safeThemePaint(theme);
+			let cache: { key: string; lines: string[] } | undefined;
+			return {
+				render: (width: number) => {
+					const shown = queued();
+					const key = `${width}:${shown}`;
+					if (cache?.key === key) return cache.lines;
+					const lines = shown ? [truncateLine(paint("dim", ` ↳ ${SEND_NOW_HINT}`), width)] : [];
+					cache = { key, lines };
+					return lines;
+				},
+				invalidate: () => {
+					cache = undefined;
+				},
+			};
+		});
+	});
+}

package/extensions/session-title/index.ts

@@ -27,6 +27,7 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { withReasoningFallback } from "../lib/model-policy.ts";
 import { pickEconomicalContainedModel } from "../lib/model-tier.ts";
 import { sessionOutlivesTurn } from "../lib/notifications.ts";
+import { isUserRun } from "../lib/prompt-options.ts";
 import { recordUsage } from "../lib/usage-bus.ts";
 import { firstUserText, isNameableText, parseTitle, SESSION_TITLE_PROMPT, sessionTitleInput } from "./title.ts";
 
@@ -61,6 +62,8 @@ export default function sessionTitleExtension(pi: ExtensionAPI) {
 		// message never changes, so it is examined once: a first message that is
 		// not prose (a breadcrumb, a slash command sent as text) leaves the
 		// session unnamed rather than re-scanning the entries every turn.
+		// A run an extension opened (pi 1.2.0) carries no prompt: wait for the user's.
+		if (!isUserRun(event)) return;
 		attempted = true;
 		const text = firstUserText(ctx.sessionManager.getEntries() as never) ?? event.prompt;
 		if (!isNameableText(text)) return;

package/extensions/session-title/title.ts

@@ -14,6 +14,7 @@
 
 import { LOCAL_COMMAND_TAG_PREFIXES } from "../lib/local-command.ts";
 import { customMessageText } from "../lib/tui-render.ts";
+import { sanitizeTitle } from "../lib/terminal-text.ts";
 
 /** CC's naming instruction (system prompt), verbatim from the 2.1.278 capture. */
 export const SESSION_TITLE_PROMPT =
@@ -86,7 +87,9 @@ function titleFromJson(text: string): string | undefined {
 }
 
 function normalizeTitle(raw: string): string | undefined {
-	const title = raw.replace(/\s+/g, " ").trim();
+	// The title becomes the terminal title inside pi's own OSC 0: an embedded
+	// BEL or ESC would end that sequence and run the rest as terminal output.
+	const title = sanitizeTitle(raw);
 	if (!title || title.length > MAX_TITLE_LENGTH) return undefined;
 	// CC: "Capitalize the first letter of the title."
 	return title[0].toUpperCase() + title.slice(1);

package/extensions/skill/code-review.ts

@@ -0,0 +1,97 @@
+/**
+ * Which `/code-review` body a session gets (pure apart from reading the cell
+ * files). Claude Code no longer has one body: it picks a "cell" by the model
+ * and the effort level, from one table per model family. One Code keys the
+ * same choice by prompt tier:
+ *
+ * - frontier takes Claude Code's default table, the one its Opus 5.5,
+ *   Sonnet 5.5 and Fable sessions use (minimal prompt at medium, inline
+ *   angles at high and xhigh, a verified fan-out at max);
+ * - workhorse, cheap and tiny take its Sonnet 5 table: the long, explicit
+ *   recipe (finder angles fanned out over the Agent tool, a verify vote)
+ *   written for the one model below that line Claude Code tunes a table for.
+ *   Claude Code's default table reaches its older models only because they
+ *   have no table of their own; its medium cell leaves the whole review to
+ *   the model's judgment, which the lower tiers' registers exist to avoid.
+ *
+ * The effort is the level the user typed first (`/code-review high 123`),
+ * else the session's (`/effort`). Claude Code runs Opus 5.5's medium cell as
+ * a background fork; here every cell runs in the session's own turn.
+ *
+ * The cells are Claude Code's text in `skills/code-review/cells/`; the minimal
+ * prompt reports through the JSON array the other cells use, since One Code
+ * has no findings tool. Every cell is followed by One Code's "Arguments and
+ * flags" section.
+ */
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { PromptTier } from "../lib/model-tier.ts";
+
+export const REVIEW_EFFORTS = ["low", "medium", "high", "xhigh", "max"] as const;
+export type ReviewEffort = (typeof REVIEW_EFFORTS)[number];
+
+/** Claude Code's default table (`cells/<name>.md`). */
+const DEFAULT_TABLE: Record<ReviewEffort, string> = {
+	low: "low-1-pass-max4",
+	medium: "minimal-prompt",
+	high: "high-8-inline",
+	xhigh: "xhigh-10-inline-sweep",
+	max: "max-5x5-verify-sweep",
+};
+
+/** Claude Code's Sonnet 5 table. */
+const SONNET5_TABLE: Record<ReviewEffort, string> = {
+	low: "low-1-pass-min-files-4",
+	medium: "medium-3x5-verify",
+	high: "high-3x5-recall-verify",
+	xhigh: "xhigh-5x5-verify-sweep",
+	max: "max-5x5-verify-sweep",
+};
+
+export const ARGUMENTS_AND_FLAGS = "arguments-and-flags";
+
+export function codeReviewCell(tier: PromptTier, effort: ReviewEffort): string {
+	return (tier === "frontier" ? DEFAULT_TABLE : SONNET5_TABLE)[effort];
+}
+
+/** The review effort for a session thinking level: below low reads as low, unknown as medium (Claude Code's default). */
+export function reviewEffortFor(thinkingLevel: string | undefined): ReviewEffort {
+	switch (thinkingLevel) {
+		case "off":
+		case "minimal":
+		case "low":
+			return "low";
+		case "high":
+		case "xhigh":
+		case "max":
+			return thinkingLevel;
+		default:
+			return "medium";
+	}
+}
+
+/** A typed level as the first argument (`/code-review high 123`) and what follows it. */
+export function parseCodeReviewArgs(args: string): { effort?: ReviewEffort; rest: string } {
+	const match = /^\s*(\S+)(?:\s+([\s\S]*))?$/.exec(args);
+	const first = match?.[1]?.toLowerCase();
+	if (!first || !(REVIEW_EFFORTS as readonly string[]).includes(first)) return { rest: args.trim() };
+	return { effort: first as ReviewEffort, rest: (match?.[2] ?? "").trim() };
+}
+
+/**
+ * The body for a session: the chosen cell, then the flags section. `args`
+ * comes back without the typed level, which the cell already reflects.
+ */
+export function codeReviewBody(
+	cellsDir: string,
+	tier: PromptTier,
+	thinkingLevel: string | undefined,
+	args: string,
+): { body: string; args: string; cell: string } {
+	const { effort, rest } = parseCodeReviewArgs(args);
+	const cell = codeReviewCell(tier, effort ?? reviewEffortFor(thinkingLevel));
+	// A checkout that turned line endings into CRLF still sends Claude Code's bytes.
+	const read = (name: string) => readFileSync(join(cellsDir, `${name}.md`), "utf-8").replace(/\r\n/g, "\n").trimEnd();
+	return { body: `${read(cell)}\n\n${read(ARGUMENTS_AND_FLAGS)}`, args: rest, cell };
+}