one-code-extension 0.1.4 → 0.3.0

package/extensions/skill/listing.ts

@@ -0,0 +1,21 @@
+/**
+ * The model-facing skills listing (pure). The state decides visibility: "on"
+ * carries name + description, "name-only" just the name (saving context
+ * tokens), "user-only"/"off" are hidden so the model won't auto-trigger them.
+ * The description goes in whole, newlines included, the way Claude Code lists
+ * it: a skill written with a YAML block description puts its "Use when…"
+ * trigger on the later lines, and a first-line-only listing dropped exactly
+ * the sentence that tells the model when to reach for the skill.
+ */
+
+import { type SkillState, skillListingVisibility } from "../lib/skill-overrides.ts";
+
+export function skillListingText(skills: ReadonlyArray<{ name: string; description?: string; state: SkillState }>): string {
+	const lines = skills.flatMap((skill) => {
+		const visibility = skillListingVisibility(skill.state);
+		if (visibility === "hidden") return [];
+		if (visibility === "name") return [`- ${skill.name}`];
+		return [`- ${skill.name}${skill.description?.trim() ? `: ${skill.description.trim()}` : ""}`];
+	});
+	return lines.length === 0 ? "(no skills available)" : lines.join("\n");
+}

package/extensions/skill/panel/keys.ts

@@ -0,0 +1,41 @@
+/**
+ * Raw-byte key decoding for the /skills panel (pure).
+ *
+ * Same control-byte map as the /plugins panel; kept local so the skill
+ * extension carries no dependency on another extension's internals. Printable
+ * input is a `text` intent the state layer routes (into the search box, or as a
+ * single-letter action when search is inactive). Skill names never contain
+ * spaces, so Space is always the cycle action, never typed.
+ */
+
+export type SkillsKey =
+	| { kind: "up" | "down" | "enter" | "space" | "back" | "backspace" | "close" }
+	| { kind: "text"; text: string };
+
+export function decodeSkillsKey(data: string): SkillsKey | undefined {
+	switch (data) {
+		case "\x1b[A":
+		case "\x1bOA":
+			return { kind: "up" };
+		case "\x1b[B":
+		case "\x1bOB":
+			return { kind: "down" };
+		case "\r":
+		case "\n":
+			return { kind: "enter" };
+		case " ":
+			return { kind: "space" };
+		case "\x1b":
+			return { kind: "back" };
+		case "\x7f":
+		case "\b":
+			return { kind: "backspace" };
+		case "\x03":
+			return { kind: "close" };
+		default:
+			break;
+	}
+	if (data.startsWith("\x1b")) return undefined;
+	const text = [...data].filter((ch) => ch >= " " && ch !== "\x7f").join("");
+	return text ? { kind: "text", text } : undefined;
+}

package/extensions/skill/panel/render.ts

@@ -0,0 +1,91 @@
+/**
+ * /skills panel rendering (pure).
+ *
+ * Returns plain lines already cut to width; the wiring wraps them in a
+ * memoized component and applies a final ANSI-aware truncate. Mirrors Claude
+ * Code's Skills menu: one row per skill, a state glyph, token estimate, and
+ * scope, with plugin skills shown locked (managed via /plugins). Only width-1
+ * glyphs are used — cutPlainText counts code points, so a wide emoji would
+ * under-measure and risk pi's overwide-line crash.
+ */
+
+import { cutPlainText, padPlainText, panelTopRule, searchBoxLines, visibleWidth } from "../../lib/tui-render.ts";
+import type { SkillState } from "../../lib/skill-overrides.ts";
+import { clampSkillsCursor, type SkillsPanelState, type SkillsRow, visibleRows } from "./state.ts";
+
+export interface SkillsPaint {
+	fg: (color: string, text: string) => string;
+	bold: (text: string) => string;
+}
+
+export interface SkillsRenderInput {
+	state: SkillsPanelState;
+	rows: SkillsRow[];
+	width: number;
+	height: number;
+	notice?: string;
+}
+
+const GLYPH: Record<SkillState, string> = { on: "✔", "name-only": "●", "user-only": "○", off: "✘" };
+const LABEL: Record<SkillState, string> = { on: "on", "name-only": "name-only", "user-only": "user-only", off: "off" };
+const COLOR: Record<SkillState, string> = { on: "success", "name-only": "accent", "user-only": "warning", off: "error" };
+/** Width of the state column, sized to the longest label ("● name-only"). */
+const STATE_WIDTH = 12;
+
+function rowLine(row: SkillsRow, isCursor: boolean, paint: SkillsPaint, width: number): string {
+	const marker = isCursor ? "❯ " : "  ";
+	const suffix = row.locked ? ` · ${row.pluginName ?? "plugin"} · locked` : "";
+	const meta = ` · ${row.scope} · ~${row.tokens} tok${suffix}`;
+	const label = padPlainText(`${GLYPH[row.state]} ${LABEL[row.state]}`, STATE_WIDTH);
+	const plainHead = `${marker}${label}${row.name}`;
+	// One flat highlight for the cursor row, like the /plugins panel.
+	if (isCursor) return paint.fg("accent", cutPlainText(plainHead + meta, width - 1));
+	const color = row.locked ? "dim" : COLOR[row.state];
+	// Cut the meta on the visible-length budget left after the head, then paint.
+	const remaining = Math.max(0, width - 1 - visibleWidth(plainHead));
+	return `${marker}${paint.fg(color, label)}${row.name}${paint.fg("dim", cutPlainText(meta, remaining))}`;
+}
+
+/** Slide a window over the rows so the cursor stays visible within `budget` lines. */
+function window<T>(items: T[], cursor: number, budget: number): { slice: T[]; start: number; more: number } {
+	if (items.length <= budget) return { slice: items, start: 0, more: 0 };
+	let start = Math.min(cursor, items.length - budget);
+	if (cursor < start) start = cursor;
+	if (cursor >= start + budget) start = cursor - budget + 1;
+	start = Math.max(0, start);
+	return { slice: items.slice(start, start + budget), start, more: items.length - (start + budget) };
+}
+
+export function renderSkillsPanel(input: SkillsRenderInput, paint: SkillsPaint): string[] {
+	const { state, rows, width, height } = input;
+	const visible = visibleRows(rows, state);
+	clampSkillsCursor(state, visible);
+
+	const out: string[] = [panelTopRule(paint.fg, width)];
+	out.push(` ${paint.bold("Skills")}`);
+	const sortNote = state.sort === "state" ? "sorted by state" : "sorted by name";
+	out.push(paint.fg("dim", cutPlainText(` ${rows.length} skill${rows.length === 1 ? "" : "s"} · ${sortNote} · enter/space to cycle, / to search, t to sort, Esc to close`, width - 1)));
+	out.push("");
+	out.push(...searchBoxLines(state.search, "Search skills…", paint.fg, width));
+	out.push("");
+
+	// Reserve: header(2) + blank + search + blank already pushed = out.length;
+	// leave room for the "more" line, notice, blank, and footer note.
+	const footerReserve = 3 + (input.notice ? 1 : 0);
+	const budget = Math.max(1, height - out.length - footerReserve);
+
+	if (visible.length === 0) {
+		out.push(paint.fg("dim", state.search ? "  No skills match your search." : "  No skills found."));
+	} else {
+		const win = window(visible, state.cursor, budget);
+		for (let i = 0; i < win.slice.length; i++) {
+			out.push(rowLine(win.slice[i], win.start + i === state.cursor, paint, width));
+		}
+		if (win.more > 0) out.push(paint.fg("dim", `  ↓ ${win.more} more`));
+	}
+
+	if (input.notice) out.push(paint.fg("warning", cutPlainText(`  ${input.notice}`, width - 1)));
+	out.push("");
+	out.push(paint.fg("dim", cutPlainText(" Plugin skills are managed via /plugins", width - 1)));
+	return out;
+}

package/extensions/skill/panel/state.ts

@@ -0,0 +1,115 @@
+/**
+ * /skills panel state machine (pure — no pi, no fs).
+ *
+ * The wiring (skill/index.ts) builds the row list from disk each repaint and
+ * owns persistence; this module owns cursor/search/sort and turns keys into
+ * effects. Filtering and sorting are pure functions over the row list so the
+ * renderer and the key handler agree on what "the selected row" is.
+ */
+
+import type { SkillScope, SkillState } from "../../lib/skill-overrides.ts";
+import type { SkillsKey } from "./keys.ts";
+
+export interface SkillsRow {
+	/** Override-store key, `<scope>:<name>`. */
+	key: string;
+	name: string;
+	scope: SkillScope;
+	tokens: number;
+	/** Current state; for locked (plugin) rows this is the effective on/off. */
+	state: SkillState;
+	/** Plugin/MCP skills can't be cycled here — managed via /plugins. */
+	locked: boolean;
+	pluginName?: string;
+}
+
+export type SkillsSort = "name" | "state";
+
+export interface SkillsPanelState {
+	cursor: number;
+	search: string;
+	searching: boolean;
+	sort: SkillsSort;
+}
+
+export type SkillsEffect = { kind: "close" } | { kind: "cycle"; row: SkillsRow } | { kind: "locked"; row: SkillsRow };
+
+export function initialSkillsState(): SkillsPanelState {
+	return { cursor: 0, search: "", searching: false, sort: "name" };
+}
+
+/** State-sort order groups by availability, most-available first, locked last. */
+const STATE_ORDER: Record<SkillState, number> = { on: 0, "name-only": 1, "user-only": 2, off: 3 };
+
+export function visibleRows(rows: SkillsRow[], state: SkillsPanelState): SkillsRow[] {
+	const query = state.search.trim().toLowerCase();
+	const filtered = query ? rows.filter((row) => row.name.toLowerCase().includes(query)) : rows.slice();
+	const rank = (row: SkillsRow) => (row.locked ? 4 : STATE_ORDER[row.state]);
+	filtered.sort((a, b) => {
+		if (state.sort === "state") {
+			const diff = rank(a) - rank(b);
+			if (diff !== 0) return diff;
+		}
+		return a.name.localeCompare(b.name);
+	});
+	return filtered;
+}
+
+export function clampSkillsCursor(state: SkillsPanelState, visible: SkillsRow[]): void {
+	if (visible.length === 0) {
+		state.cursor = 0;
+		return;
+	}
+	state.cursor = Math.max(0, Math.min(state.cursor, visible.length - 1));
+}
+
+/**
+ * Fold a key into the state, returning an effect the wiring must act on. The
+ * caller passes the already-filtered/sorted rows so "the selected row" matches
+ * what the renderer drew.
+ */
+export function applySkillsKey(state: SkillsPanelState, key: SkillsKey, visible: SkillsRow[]): SkillsEffect | undefined {
+	clampSkillsCursor(state, visible);
+	switch (key.kind) {
+		case "close":
+			return { kind: "close" };
+		case "up":
+			state.cursor = Math.max(0, state.cursor - 1);
+			return;
+		case "down":
+			state.cursor = Math.min(Math.max(0, visible.length - 1), state.cursor + 1);
+			return;
+		case "space":
+		case "enter": {
+			const row = visible[state.cursor];
+			if (!row) return;
+			return row.locked ? { kind: "locked", row } : { kind: "cycle", row };
+		}
+		case "backspace":
+			if (state.searching) state.search = state.search.slice(0, -1);
+			return;
+		case "back":
+			// Esc leaves search first, then closes the panel.
+			if (state.searching || state.search) {
+				state.searching = false;
+				state.search = "";
+				return;
+			}
+			return { kind: "close" };
+		case "text": {
+			if (!state.searching) {
+				if (key.text === "/") {
+					state.searching = true;
+					return;
+				}
+				if (key.text === "t") {
+					state.sort = state.sort === "name" ? "state" : "name";
+					return;
+				}
+				return;
+			}
+			state.search += key.text;
+			return;
+		}
+	}
+}

package/extensions/spinner/index.ts

@@ -0,0 +1,110 @@
+/**
+ * spinner extension — Claude Code's live-activity chrome around the prompt:
+ *
+ * - The working line: pi's spinner becomes CC's animated asterisk (✳ frame
+ *   cycle) with a random gerund verb per turn and live stats — "Hyperspacing…
+ *   (10s · ↓ 448 tokens)" — updated on a 1s ticker while the model streams.
+ *   Tokens are CC's estimate (streamed characters / 4).
+ *
+ * Context usage is shown by the footer extension, not here (the two once
+ * duplicated an above-input token counter).
+ *
+ * Matched to a frame capture of CC 2.1.233. CC's glimmer animation and
+ * rotating tip lines are deliberately not replicated (pi renders the working
+ * message as plain text, and tips carry CC's own frequency machinery).
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { safeThemePaint } from "../lib/tui-render.ts";
+import { composeWorkingMessage, messageChars, spinnerFrames } from "./line.ts";
+import { pickVerb } from "./verbs.ts";
+
+const FRAME_INTERVAL_MS = 120;
+const TICK_MS = 1000;
+
+export default function spinnerExtension(pi: ExtensionAPI) {
+	let lastCtx: ExtensionContext | undefined;
+	let verb = pickVerb();
+	let turnStartedAt = 0;
+	/** Characters from finished assistant messages this turn. */
+	let settledChars = 0;
+	/**
+	 * The streaming message, summed lazily on the 1s ticker — message_update
+	 * fires per token carrying the whole message-so-far, so counting there
+	 * would be O(n²) over a long response.
+	 */
+	let streamingMessage: unknown;
+	let ticker: ReturnType<typeof setInterval> | undefined;
+
+	const updateWorkingMessage = () => {
+		const ctx = lastCtx;
+		if (!ctx?.hasUI || !turnStartedAt) return;
+		ctx.ui.setWorkingMessage(
+			composeWorkingMessage({
+				verb,
+				elapsedMs: Date.now() - turnStartedAt,
+				responseChars: settledChars + messageChars(streamingMessage),
+			}),
+		);
+	};
+
+	const stopTicker = () => {
+		if (ticker) clearInterval(ticker);
+		ticker = undefined;
+	};
+
+	pi.on("session_start", (_event, ctx) => {
+		lastCtx = ctx;
+		if (!ctx.hasUI) return;
+		const paint = safeThemePaint(ctx.ui.theme);
+		ctx.ui.setWorkingIndicator({
+			frames: spinnerFrames(process.platform, process.env.TERM).map((frame) => paint("accent", frame)),
+			intervalMs: FRAME_INTERVAL_MS,
+		});
+	});
+
+	pi.on("agent_start", (_event, ctx) => {
+		lastCtx = ctx;
+		// A turn can hold several runs (provider retry, auto-compaction, queued
+		// follow-up — findings §3): a later run joins the open span, keeping the
+		// first run's start and verb, so the elapsed shown is the time the user
+		// has actually waited (the live counterpart of turn-duration's TurnSpan).
+		if (!turnStartedAt) {
+			verb = pickVerb();
+			turnStartedAt = Date.now();
+			settledChars = 0;
+		}
+		streamingMessage = undefined;
+		updateWorkingMessage();
+		if (!ticker) {
+			ticker = setInterval(updateWorkingMessage, TICK_MS);
+			ticker.unref?.();
+		}
+	});
+
+	pi.on("message_update", (event) => {
+		if (event.message.role !== "assistant") return;
+		streamingMessage = event.message;
+	});
+
+	pi.on("message_end", (event) => {
+		if (event.message.role === "assistant") {
+			settledChars += messageChars(event.message);
+			streamingMessage = undefined;
+		}
+	});
+
+	// Settle, not agent_end: `agent_end` fires per run, and stopping there made
+	// the counter restart from zero on a provider retry. The ticker runs through
+	// the backoff so the elapsed keeps counting, and stops (for any outcome,
+	// unlike the gated duration line) only when pi will not continue by itself.
+	pi.on("agent_settled", (_event, ctx) => {
+		stopTicker();
+		turnStartedAt = 0;
+		if (ctx.hasUI) ctx.ui.setWorkingMessage(); // restore pi's default for non-turn work
+	});
+
+	pi.on("session_shutdown", () => {
+		stopTicker();
+	});
+}

package/extensions/spinner/line.ts

@@ -0,0 +1,51 @@
+/**
+ * Pure pieces of the Claude Code working line ("✳ Hyperspacing… (10s · ↓ 448
+ * tokens)") — formats matched to a frame capture of CC 2.1.233 plus its
+ * reconstructed Spinner source.
+ */
+
+import { formatDuration } from "../lib/tui-render.ts";
+import { formatTokenCount } from "../subagents/usage.ts";
+
+/**
+ * CC's spinner glyph frames (Spinner/utils.ts), mirrored forward-then-back.
+ * Ghostty gets `*` for ✽ (renders offset there); non-mac gets `*` for ✳.
+ */
+export function spinnerFrames(platform: string, term: string | undefined): string[] {
+	const chars =
+		term === "xterm-ghostty"
+			? ["·", "✢", "✳", "✶", "✻", "*"]
+			: platform === "darwin"
+				? ["·", "✢", "✳", "✶", "✻", "✽"]
+				: ["·", "✢", "*", "✶", "✻", "✽"];
+	return [...chars, ...[...chars].reverse()];
+}
+
+/** CC estimates streamed tokens as response characters / 4. */
+export function estimateTokens(responseChars: number): number {
+	return Math.round(responseChars / 4);
+}
+
+/**
+ * `Verb… (elapsed · ↓ N tokens)` — the token part appears once anything has
+ * streamed, formatted compactly the way CC's formatNumber does (448, 1.3k).
+ */
+export function composeWorkingMessage(input: { verb: string; elapsedMs: number; responseChars: number }): string {
+	const parts = [formatDuration(0, input.elapsedMs)];
+	const tokens = estimateTokens(input.responseChars);
+	if (tokens > 0) parts.push(`↓ ${formatTokenCount(tokens)} tokens`);
+	return `${input.verb}… (${parts.join(" · ")})`;
+}
+
+/** Character count of an assistant message's streamed text + thinking blocks. */
+export function messageChars(message: unknown): number {
+	const content = (message as { content?: unknown })?.content;
+	if (!Array.isArray(content)) return 0;
+	let total = 0;
+	for (const block of content) {
+		const b = block as { type?: string; text?: string; thinking?: string };
+		if (typeof b?.text === "string") total += b.text.length;
+		if (typeof b?.thinking === "string") total += b.thinking.length;
+	}
+	return total;
+}

package/extensions/spinner/verbs.ts

@@ -0,0 +1,201 @@
+/**
+ * Claude Code's spinner verbs, verbatim from the reconstructed source
+ * (src/constants/spinnerVerbs.ts) — the whimsical gerund shown while the
+ * model works ("✳ Hyperspacing…"). One is picked at random per turn.
+ */
+
+export const SPINNER_VERBS: readonly string[] = [
+	"Accomplishing",
+	"Actioning",
+	"Actualizing",
+	"Architecting",
+	"Baking",
+	"Beaming",
+	"Beboppin'",
+	"Befuddling",
+	"Billowing",
+	"Blanching",
+	"Bloviating",
+	"Boogieing",
+	"Boondoggling",
+	"Booping",
+	"Bootstrapping",
+	"Brewing",
+	"Bunning",
+	"Burrowing",
+	"Calculating",
+	"Canoodling",
+	"Caramelizing",
+	"Cascading",
+	"Catapulting",
+	"Cerebrating",
+	"Channeling",
+	"Channelling",
+	"Choreographing",
+	"Churning",
+	"Clauding",
+	"Coalescing",
+	"Cogitating",
+	"Combobulating",
+	"Composing",
+	"Computing",
+	"Concocting",
+	"Considering",
+	"Contemplating",
+	"Cooking",
+	"Crafting",
+	"Creating",
+	"Crunching",
+	"Crystallizing",
+	"Cultivating",
+	"Deciphering",
+	"Deliberating",
+	"Determining",
+	"Dilly-dallying",
+	"Discombobulating",
+	"Doing",
+	"Doodling",
+	"Drizzling",
+	"Ebbing",
+	"Effecting",
+	"Elucidating",
+	"Embellishing",
+	"Enchanting",
+	"Envisioning",
+	"Evaporating",
+	"Fermenting",
+	"Fiddle-faddling",
+	"Finagling",
+	"Flambéing",
+	"Flibbertigibbeting",
+	"Flowing",
+	"Flummoxing",
+	"Fluttering",
+	"Forging",
+	"Forming",
+	"Frolicking",
+	"Frosting",
+	"Gallivanting",
+	"Galloping",
+	"Garnishing",
+	"Generating",
+	"Gesticulating",
+	"Germinating",
+	"Gitifying",
+	"Grooving",
+	"Gusting",
+	"Harmonizing",
+	"Hashing",
+	"Hatching",
+	"Herding",
+	"Honking",
+	"Hullaballooing",
+	"Hyperspacing",
+	"Ideating",
+	"Imagining",
+	"Improvising",
+	"Incubating",
+	"Inferring",
+	"Infusing",
+	"Ionizing",
+	"Jitterbugging",
+	"Julienning",
+	"Kneading",
+	"Leavening",
+	"Levitating",
+	"Lollygagging",
+	"Manifesting",
+	"Marinating",
+	"Meandering",
+	"Metamorphosing",
+	"Misting",
+	"Moonwalking",
+	"Moseying",
+	"Mulling",
+	"Mustering",
+	"Musing",
+	"Nebulizing",
+	"Nesting",
+	"Newspapering",
+	"Noodling",
+	"Nucleating",
+	"Orbiting",
+	"Orchestrating",
+	"Osmosing",
+	"Perambulating",
+	"Percolating",
+	"Perusing",
+	"Philosophising",
+	"Photosynthesizing",
+	"Pollinating",
+	"Pondering",
+	"Pontificating",
+	"Pouncing",
+	"Precipitating",
+	"Prestidigitating",
+	"Processing",
+	"Proofing",
+	"Propagating",
+	"Puttering",
+	"Puzzling",
+	"Quantumizing",
+	"Razzle-dazzling",
+	"Razzmatazzing",
+	"Recombobulating",
+	"Reticulating",
+	"Roosting",
+	"Ruminating",
+	"Sautéing",
+	"Scampering",
+	"Schlepping",
+	"Scurrying",
+	"Seasoning",
+	"Shenaniganing",
+	"Shimmying",
+	"Simmering",
+	"Skedaddling",
+	"Sketching",
+	"Slithering",
+	"Smooshing",
+	"Sock-hopping",
+	"Spelunking",
+	"Spinning",
+	"Sprouting",
+	"Stewing",
+	"Sublimating",
+	"Swirling",
+	"Swooping",
+	"Symbioting",
+	"Synthesizing",
+	"Tempering",
+	"Thinking",
+	"Thundering",
+	"Tinkering",
+	"Tomfoolering",
+	"Topsy-turvying",
+	"Transfiguring",
+	"Transmuting",
+	"Twisting",
+	"Undulating",
+	"Unfurling",
+	"Unravelling",
+	"Vibing",
+	"Waddling",
+	"Wandering",
+	"Warping",
+	"Whatchamacalliting",
+	"Whirlpooling",
+	"Whirring",
+	"Whisking",
+	"Wibbling",
+	"Working",
+	"Wrangling",
+	"Zesting",
+	"Zigzagging",
+];
+
+/** Random verb for one turn; `random` is injectable for tests. */
+export function pickVerb(random: () => number = Math.random): string {
+	const index = Math.min(SPINNER_VERBS.length - 1, Math.floor(random() * SPINNER_VERBS.length));
+	return SPINNER_VERBS[index];
+}