one-code-extension 0.4.0 → 0.5.0

package/extensions/btw/panel.ts

@@ -1,86 +1,110 @@
 /**
- * Pure state, key decoding, and rendering for the `/btw` answer overlay — Claude
- * Code's side-question panel: a focused, scrollable view of the answer with the
- * question dim above it. `↑/↓` (and PgUp/PgDn) scroll, `c` copies the answer,
- * `Esc` closes.
+ * Pure state, key decoding, and rendering for the `/btw` panel, laid out as
+ * Claude Code's: the session's earlier side questions (the last five, with a
+ * count of older ones), the current question marked `/btw`, the answer
+ * indented under them, and a hint line naming only the keys that apply.
  *
- * Kept free of pi imports so the scroll maths and layout are unit-tested; the
- * extension owns the overlay, repaint, and the actual clipboard write. CC's
- * panel also offers `f to fork`; One Code omits it (pi exposes no primitive to
- * branch a session with an injected exchange) — docs/decisions/btw.md.
+ * Shift+←/→, `[`/`]` and Tab/Shift+Tab browse the earlier answers, ↑/↓ scroll
+ * (PgUp/PgDn and Home/End too), `c` copies the answer on screen, `f` forks the
+ * current answer into a background subagent, `x` clears the history, and Esc,
+ * Enter, Space or `q` close.
+ *
+ * Kept free of pi imports so the browse and scroll maths and the layout are
+ * unit-tested; the extension owns the overlay, the model call, the clipboard
+ * write and the fork request.
  */
 
-import { panelTopRule, safeThemePaint, truncateLine, wrapPlainText } from "../lib/tui-render.ts";
+import type { BtwExchange } from "./prompt.ts";
+import { keyId, keyText } from "../lib/key-input.ts";
+import { panelTopRule, safeThemeBold, safeThemePaint, truncateLine, wrapPlainText } from "../lib/tui-render.ts";
 
 export const BTW_MAX_HEIGHT = 24;
 
-/** Key hint shown at the foot of the panel. Every key here is discoverable. */
-export const BTW_HINT = "↑/↓ to scroll · c to copy · Esc to close";
+/** Earlier questions listed (and browsable) above the current one. */
+export const SHOWN_HISTORY = 5;
 
-/** Most echoed question lines shown in the header, so it can't starve the body. */
-export const MAX_QUESTION_LINES = 4;
+/** Lines one ↑/↓ press scrolls. */
+const SCROLL_STEP = 3;
 
-/**
- * The panel's body state. The pure module owns the text for each phase so every
- * appearance (loading, error, answer) is rendered — and tested — here rather
- * than assembled by the extension wiring.
- */
-export type BtwBody = { kind: "loading" } | { kind: "error"; message: string } | { kind: "answer"; text: string };
+/** Columns the answer is indented by, under the question list. */
+const ANSWER_INDENT = 4;
 
-/** The text shown in the body for a given phase. */
-function bodyText(body: BtwBody): string {
-	switch (body.kind) {
-		case "loading":
-			return "Thinking…";
-		case "error":
-			return `Side question failed: ${body.message}`;
-		case "answer":
-			return body.text || "(no answer)";
-	}
-}
+/** Columns the question list is indented by. */
+const LIST_INDENT = 2;
+
+/** The current question's body: its answer, a failure, or still waiting. */
+export type BtwBody = { kind: "loading" } | { kind: "error"; message: string } | { kind: "answer"; text: string };
 
 export interface BtwPanelState {
-	/** First body line shown (0 = top). */
+	/** First answer line shown (0 = top). */
 	offset: number;
 	/** Largest valid offset for the current viewport; render keeps it current. */
 	maxOffset: number;
-	/** Visible body lines in the current viewport; render keeps it current. */
+	/** Visible answer lines in the current viewport; render keeps it current. */
 	viewport: number;
-	/** Set for one frame after a copy so the footer can confirm it. */
+	/** Set for one frame after a copy so the hint can confirm it. */
 	copied: boolean;
+	/** Why the last copy failed (no clipboard route), shown in the hint until the next key. */
+	copyError?: string;
+	/** The earlier exchange on screen (an index into the history), or null for the current question. */
+	selected: number | null;
 }
 
 export function initialBtwState(): BtwPanelState {
-	return { offset: 0, maxOffset: 0, viewport: 1, copied: false };
+	return { offset: 0, maxOffset: 0, viewport: 1, copied: false, selected: null };
 }
 
-export type BtwKey = { kind: "up" | "down" | "pageUp" | "pageDown" | "top" | "bottom" | "copy" | "close" };
+export type BtwKey =
+	| { kind: "up" | "down" | "pageUp" | "pageDown" | "top" | "bottom" | "copy" | "fork" | "clear" | "close" }
+	| { kind: "browse"; direction: "older" | "newer"; wrap: boolean };
 
 export function decodeBtwKey(data: string): BtwKey | undefined {
-	switch (data) {
-		case "\x1b[A":
-		case "\x1bOA":
-		case "\x10": // ctrl+p
+	switch (keyId(data)) {
+		case "up":
+		case "ctrl+p":
 			return { kind: "up" };
-		case "\x1b[B":
-		case "\x1bOB":
-		case "\x0e": // ctrl+n
+		case "down":
+		case "ctrl+n":
 			return { kind: "down" };
-		case "\x1b[5~":
+		case "pageUp":
 			return { kind: "pageUp" };
-		case "\x1b[6~":
+		case "pageDown":
 			return { kind: "pageDown" };
-		case "\x1b[H":
-		case "\x1bOH":
+		case "home":
 			return { kind: "top" };
-		case "\x1b[F":
-		case "\x1bOF":
+		case "end":
 			return { kind: "bottom" };
+		case "shift+left":
+			return { kind: "browse", direction: "older", wrap: false };
+		case "shift+right":
+			return { kind: "browse", direction: "newer", wrap: false };
+		case "tab":
+			return { kind: "browse", direction: "older", wrap: true };
+		case "shift+tab":
+			return { kind: "browse", direction: "newer", wrap: true };
+		case "escape":
+		case "ctrl+c":
+		case "ctrl+d":
+		case "enter":
+		case "space":
+			return { kind: "close" };
+		default:
+			break;
+	}
+	switch (keyText(data)) {
+		case "[":
+			return { kind: "browse", direction: "older", wrap: false };
+		case "]":
+			return { kind: "browse", direction: "newer", wrap: false };
 		case "c":
 		case "C":
 			return { kind: "copy" };
-		case "\x1b":
-		case "\x03": // ctrl+c
+		case "f":
+		case "F":
+			return { kind: "fork" };
+		case "x":
+		case "X":
+			return { kind: "clear" };
 		case "q":
 			return { kind: "close" };
 		default:
@@ -88,7 +112,7 @@ export function decodeBtwKey(data: string): BtwKey | undefined {
 	}
 }
 
-export type BtwEffect = { kind: "copy" } | { kind: "close" };
+export type BtwEffect = { kind: "copy" } | { kind: "fork" } | { kind: "clear" } | { kind: "close" };
 
 /** Page size for PgUp/PgDn: nearly a full viewport, one line of overlap for orientation. */
 function pageStep(viewport: number): number {
@@ -96,26 +120,68 @@ function pageStep(viewport: number): number {
 }
 
 /**
- * Apply a key to the scroll state. Returns an effect for the extension to run
- * (copy, close) or undefined for a scroll (repaint only). Offsets are clamped to
- * `state.maxOffset`, and pages by `state.viewport` — both set by the most recent
- * render from the real viewport.
+ * Move the selection one step through the current question and the last
+ * SHOWN_HISTORY earlier ones (Claude Code's order: older goes up the list).
+ * Without `wrap` it stops at either end; with it, it cycles.
  */
-export function applyBtwKey(state: BtwPanelState, key: BtwKey): BtwEffect | undefined {
+function browse(state: BtwPanelState, historyLength: number, direction: "older" | "newer", wrap: boolean): void {
+	const reachable = Math.min(historyLength, SHOWN_HISTORY);
+	const distance = state.selected === null ? 0 : historyLength - state.selected;
+	const step = direction === "older" ? 1 : -1;
+	const next = wrap ? (distance + step + reachable + 1) % (reachable + 1) : Math.min(Math.max(distance + step, 0), reachable);
+	if (next === distance) return;
+	state.selected = next === 0 ? null : historyLength - next;
+	state.offset = 0;
+}
+
+/**
+ * Copy an answer and report the outcome in the hint line. pi's
+ * `copyToClipboard` rejects when no clipboard route works (Wayland without
+ * `wl-copy`, X11 without `xclip`); unhandled, that rejection ends the process,
+ * so the reason is shown in place of the confirmation instead.
+ */
+export function copyAnswer(copy: (text: string) => Promise<void>, text: string, state: BtwPanelState, repaint: () => void): Promise<void> {
+	let pending: Promise<void>;
+	try {
+		pending = Promise.resolve(copy(text));
+	} catch (error) {
+		pending = Promise.reject(error);
+	}
+	return pending.then(
+		() => {
+			state.copied = true;
+			state.copyError = undefined;
+			repaint();
+		},
+		(error: unknown) => {
+			const reason = error instanceof Error ? error.message : String(error);
+			state.copied = false;
+			state.copyError = `Copy failed: ${reason.split("\n")[0]}`;
+			repaint();
+		},
+	);
+}
+
+/**
+ * Apply a key. Returns an effect for the extension to run (copy, fork, clear,
+ * close) or undefined for a scroll or browse (repaint only). Offsets clamp to
+ * `state.maxOffset` and page by `state.viewport`, both set by the last render.
+ */
+export function applyBtwKey(state: BtwPanelState, key: BtwKey, historyLength: number): BtwEffect | undefined {
 	state.copied = false;
-	const step = pageStep(state.viewport);
+	state.copyError = undefined;
 	switch (key.kind) {
 		case "up":
-			state.offset = Math.max(0, state.offset - 1);
+			state.offset = Math.max(0, state.offset - SCROLL_STEP);
 			return undefined;
 		case "down":
-			state.offset = Math.min(state.maxOffset, state.offset + 1);
+			state.offset = Math.min(state.maxOffset, state.offset + SCROLL_STEP);
 			return undefined;
 		case "pageUp":
-			state.offset = Math.max(0, state.offset - step);
+			state.offset = Math.max(0, state.offset - pageStep(state.viewport));
 			return undefined;
 		case "pageDown":
-			state.offset = Math.min(state.maxOffset, state.offset + step);
+			state.offset = Math.min(state.maxOffset, state.offset + pageStep(state.viewport));
 			return undefined;
 		case "top":
 			state.offset = 0;
@@ -123,57 +189,119 @@ export function applyBtwKey(state: BtwPanelState, key: BtwKey): BtwEffect | unde
 		case "bottom":
 			state.offset = state.maxOffset;
 			return undefined;
+		case "browse":
+			browse(state, historyLength, key.direction, key.wrap);
+			return undefined;
 		case "copy":
-			return { kind: "copy" };
+		case "fork":
+		case "clear":
 		case "close":
-			return { kind: "close" };
+			return { kind: key.kind };
 	}
 }
 
 /**
- * Render the panel to at most `height` lines. The header (the dim question) and
- * footer (rule + key hint, with a scroll indicator and a copy confirmation) are
- * fixed; the answer scrolls within what remains. Clamps and writes back
- * `state.offset`/`state.maxOffset` so key handling scrolls against the real
- * body length. Every line is width-truncated (pi-tui crashes on an overwide
- * line).
+ * Renders an answer to lines at a width: plain wrapping by default, Markdown in
+ * the extension. `ref` is stable for one answer (its exchange, or the panel
+ * state for the current one), so a renderer can cache by it.
  */
-export function renderBtwPanel(
-	input: { state: BtwPanelState; question: string; body: BtwBody; width: number; height: number },
-	theme?: unknown,
-): string[] {
-	const { state, question, body, width, height } = input;
+export type AnswerRenderer = (text: string, width: number, ref: object) => string[];
+
+export interface BtwPanelInput {
+	state: BtwPanelState;
+	/** The session's earlier exchanges, oldest first. */
+	history: readonly BtwExchange[];
+	question: string;
+	body: BtwBody;
+	width: number;
+	height: number;
+	/** The current answer can be forked (the extension knows whether a fork can start). */
+	canFork?: boolean;
+	/** A fork request is in flight. */
+	forking?: boolean;
+	renderAnswer?: AnswerRenderer;
+}
+
+/** One question on one line, whitespace collapsed, cut to fit (Claude Code's list row). */
+function questionLine(question: string, width: number): string {
+	return truncateLine(question.replace(/\s+/g, " ").trim(), Math.max(20, width - 7));
+}
+
+/**
+ * Render the panel to at most `height` lines. The answer scrolls within what
+ * the question list and hint leave; `state.offset`, `maxOffset` and `viewport`
+ * are written back so key handling scrolls against the real answer length.
+ * Every line is width-truncated (pi-tui crashes on an overwide line).
+ */
+export function renderBtwPanel(input: BtwPanelInput, theme?: unknown): string[] {
+	const { state, history, question, body, width, height } = input;
 	const paint = safeThemePaint(theme);
+	const bold = safeThemeBold(theme);
 	const inner = Math.max(1, width);
+	const pad = " ".repeat(LIST_INDENT);
+	if (state.selected !== null && (state.selected < 0 || state.selected >= history.length)) state.selected = null;
+	const selected = state.selected === null ? undefined : history[state.selected];
 
-	// Cap the echoed question so a long one (a pasted paragraph or URL) cannot
-	// grow the header past the panel height and starve the answer of rows; a
-	// truncated last line gets an ellipsis. The answer is what scrolls, not the
-	// question.
-	const questionLines = wrapPlainText(question.trim(), inner);
-	const shownQuestion =
-		questionLines.length > MAX_QUESTION_LINES
-			? [...questionLines.slice(0, MAX_QUESTION_LINES - 1), truncateLine(`${questionLines[MAX_QUESTION_LINES - 1]}…`, inner)]
-			: questionLines;
-	const header = [
-		paint("accent", truncateLine("Side question", inner)),
-		...shownQuestion.map((line) => paint("muted", truncateLine(line, inner))),
-		panelTopRule(paint, inner),
-	];
-
-	const bodyAll = wrapPlainText(bodyText(body), inner);
-	const capacity = Math.max(1, height - header.length - 2); // 2 = footer rule + hint
+	// On a short dock, list fewer earlier questions rather than overflow it: the
+	// rule, blanks, current question, one answer row and the hint always fit.
+	// A browsed question the trimmed list leaves out takes the list's first row
+	// (the count's, if that is the only one), so its answer never shows alone.
+	const listRows = Math.max(0, height - 7);
+	let shownCount = Math.min(SHOWN_HISTORY, history.length);
+	while (shownCount > 0 && shownCount + (history.length > shownCount ? 1 : 0) > listRows) shownCount--;
+	let start = history.length - shownCount;
+	if (state.selected !== null && state.selected < start) {
+		if (shownCount === 0 && listRows > 0) shownCount = 1;
+		start = Math.min(state.selected, history.length - shownCount);
+	}
+	const shown = history.slice(start, start + shownCount);
+	const hidden = history.length - shown.length;
+	const list: string[] = [];
+	if (hidden > 0 && shownCount < listRows) list.push(paint("muted", `${pad}(+${hidden} earlier /btw)`));
+	shown.forEach((exchange, i) => {
+		const text = `${pad}/btw ${questionLine(exchange.question, inner)}`;
+		list.push(state.selected === start + i ? bold(text) : paint("muted", text));
+	});
+	const marker = selected ? paint("muted", "/btw ") : bold(paint("warning", "/btw "));
+	list.push(`${pad}${marker}${paint("muted", questionLine(question, inner))}`);
+
+	const answerWidth = Math.max(1, inner - ANSWER_INDENT);
+	const renderAnswer = input.renderAnswer ?? wrapPlainText;
+	const answerLines = selected
+		? renderAnswer(selected.answer, answerWidth, selected)
+		: body.kind === "answer"
+			? renderAnswer(body.text || "(no answer)", answerWidth, state)
+			: body.kind === "error"
+				? wrapPlainText(body.message, answerWidth).map((line) => paint("error", line))
+				: [paint("muted", "Answering…")];
+
+	const header = [panelTopRule(paint, inner), "", ...list, ""];
+	const footerRows = 2; // blank + hint
+	const capacity = Math.max(1, height - header.length - footerRows);
 	state.viewport = capacity;
-	state.maxOffset = Math.max(0, bodyAll.length - capacity);
+	state.maxOffset = Math.max(0, answerLines.length - capacity);
 	state.offset = Math.min(Math.max(0, state.offset), state.maxOffset);
+	const indent = " ".repeat(ANSWER_INDENT);
+	const visible = answerLines.slice(state.offset, state.offset + capacity).map((line) => `${indent}${line}`);
 
-	const visible = bodyAll.slice(state.offset, state.offset + capacity).map((line) => truncateLine(line, inner));
-	// Pad a short answer so the footer sits at the panel's foot, not mid-screen.
-	while (visible.length < capacity) visible.push("");
-
-	const scrollNote = state.maxOffset > 0 ? `  (${state.offset + 1}-${Math.min(state.offset + capacity, bodyAll.length)} of ${bodyAll.length})` : "";
-	const hint = state.copied ? "Copied to clipboard" : `${BTW_HINT}${scrollNote}`;
-	const footer = [panelTopRule(paint, inner), paint("muted", truncateLine(hint, inner))];
+	const currentAnswer = body.kind === "answer" && body.text !== "";
+	const hasAnswer = Boolean(selected) || currentAnswer;
+	let hint: string;
+	if (input.forking) {
+		hint = paint("muted", "Forking…");
+	} else {
+		const parts: string[] = [];
+		if (history.length > 0) parts.push(paint("muted", "⇧←/→ to browse"));
+		else if (body.kind !== "loading") parts.push(paint("muted", "↑/↓ to scroll"));
+		if (hasAnswer) {
+			if (state.copyError) parts.push(paint("error", state.copyError));
+			else parts.push(state.copied ? paint("success", "Copied to clipboard") : paint("muted", "c to copy"));
+		}
+		if (input.canFork && !selected && currentAnswer) parts.push(paint("muted", "f to fork"));
+		if (history.length > 0) parts.push(paint("muted", "x to clear history"));
+		parts.push(paint("muted", "Esc to close"));
+		hint = parts.join(paint("muted", " · "));
+	}
 
-	return [...header, ...visible, ...footer];
+	return [...header, ...visible, "", `${pad}${hint}`].map((line) => truncateLine(line, inner));
 }

package/extensions/btw/prompt.ts

@@ -6,16 +6,19 @@
  * answering model as a separate, tool-less instance, prepended to the user's
  * question as the final user message.
  *
- * Kept free of pi imports so the message assembly and text extraction are
+ * Kept free of pi imports (pi-ai types only) so the message assembly is
  * unit-tested; the extension owns the model call, the spinner, and the panel.
  */
 
+import type { Api, AssistantMessage, Message, Model, UserMessage } from "@earendil-works/pi-ai";
+
 /**
  * CC's verbatim side-question reminder (captures/btw.json message 20). It frames
  * the answering instance as a separate, lightweight, tool-less agent so the
- * model answers in one shot from context instead of trying to act. One Code
- * backs this framing for real: it sends name-only tool stubs (never live tools)
- * and does not persist the exchange, so there genuinely is no follow-up turn.
+ * model answers in one shot from context instead of trying to act. Like Claude
+ * Code, the replayed request still declares the session's real tools (they are
+ * part of the cached prefix); a tool call in the answer is never executed, only
+ * its text is shown, and the exchange never reaches the main conversation.
  */
 export const SIDE_QUESTION_REMINDER = `<system-reminder>This is a side question from the user. You must answer this question directly in a single response.
 
@@ -43,3 +46,37 @@ Simply answer the question with the information you have.</system-reminder>`;
 export function sideQuestionMessage(question: string): string {
 	return `${SIDE_QUESTION_REMINDER}\n\n${question.trim()}`;
 }
+
+/** One answered side question, kept for the rest of the session. */
+export interface BtwExchange {
+	question: string;
+	answer: string;
+}
+
+/** The model an injected assistant message is attributed to. */
+type ModelRef = Pick<Model<Api>, "api" | "provider" | "id">;
+
+/**
+ * One exchange as the user/assistant pair a later request carries: the bare
+ * question (no reminder) and the answer, as Claude Code threads its side
+ * session's history into the next side question. A fork gets the same pairs.
+ */
+export function exchangeMessages(exchange: BtwExchange, model: ModelRef, timestamp = Date.now()): Message[] {
+	const user: UserMessage = { role: "user", content: [{ type: "text", text: exchange.question }], timestamp };
+	const assistant: AssistantMessage = {
+		role: "assistant",
+		content: [{ type: "text", text: exchange.answer }],
+		api: model.api,
+		provider: model.provider,
+		model: model.id,
+		usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+		stopReason: "stop",
+		timestamp,
+	};
+	return [user, assistant];
+}
+
+/** Every earlier exchange, oldest first, as the messages sent before a new side question. */
+export function historyMessages(exchanges: readonly BtwExchange[], model: ModelRef, timestamp = Date.now()): Message[] {
+	return exchanges.flatMap((exchange) => exchangeMessages(exchange, model, timestamp));
+}

package/extensions/claude-compat/index.ts

@@ -11,7 +11,7 @@
  * It also points discovery at the catalog of skills bundled with this package
  * (`<package>/skills`) — Claude Code's self-contained built-in skills, which
  * ship inside its binary rather than on disk, so nothing else would surface
- * them. See docs/decisions/skills-plugins.md and docs/findings (the extraction
+ * them. See working-docs/decisions/skills-plugins.md and working-docs/findings (the extraction
  * process is recorded in .claude/skills/extract-cc-skills/).
  *
  * CLAUDE.md needs no handling — pi discovers it natively alongside AGENTS.md.
@@ -19,12 +19,10 @@
 
 import { existsSync } from "node:fs";
 import os from "node:os";
-import { join } from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { claudeConfigDir } from "../lib/paths.ts";
-import { claudeUserDir } from "../lib/paths.ts";
+import { claudeConfigDir, claudeUserDir } from "../lib/paths.ts";
 
-import { BUNDLED_SKILLS_DIR } from "../lib/skill-scan.ts";
+import { BUNDLED_SKILLS_DIR, commandDirs, skillSourceDirs } from "../lib/skill-scan.ts";
 
 /**
  * `claudeDir` is Claude Code's config dir (honours CLAUDE_CONFIG_DIR), defaulting
@@ -38,19 +36,17 @@ export function claudeResourcePaths(
 	claudeDir: string = claudeUserDir(home),
 	bundledSkillsDir?: string,
 ): { skillPaths: string[]; promptPaths: string[] } {
+	// The folders follow the config mode (lib/skill-scan.ts, lib/config-mode.ts).
 	const candidates = {
 		skillPaths: [
-			join(claudeDir, "skills"),
-			join(home, ".agents", "skills"),
-			join(cwd, ".claude", "skills"),
-			join(cwd, ".agents", "skills"),
+			...skillSourceDirs(cwd, home, claudeDir).map(({ dir }) => dir),
 			// The bundled catalog is listed LAST so it loses a name collision:
 			// pi keeps the first-loaded skill for a given name, so a user or
 			// project skill of the same name wins and the bundled one is the
-			// fallback (see docs/decisions/skills-plugins.md).
+			// fallback (see working-docs/decisions/skills-plugins.md).
 			...(bundledSkillsDir ? [bundledSkillsDir] : []),
 		],
-		promptPaths: [join(claudeDir, "commands"), join(cwd, ".claude", "commands")],
+		promptPaths: commandDirs(cwd, home, claudeDir),
 	};
 	return {
 		skillPaths: candidates.skillPaths.filter((p) => existsSync(p)),