@oh-my-pi/pi-tui 18.2.3 → 18.2.5

package/src/prompt/prompt-action-autocomplete.ts

@@ -0,0 +1,337 @@
+import {
+	type AutocompleteItem,
+	type AutocompleteProvider,
+	CombinedAutocompleteProvider,
+	findLeadingSlashCommandStart,
+	getKeybindings,
+	type SlashCommand,
+} from "../index";
+import { formatKeyHints, type KeybindingsManager } from "../app-keybindings";
+import { applyEmojiCompletion, getEmojiSuggestions, isEmojiPrefix, tryEmojiInlineReplace } from "./emoji-autocomplete";
+import { getGithubRefContext, getGithubRefSuggestions } from "./github-ref-autocomplete";
+import {
+	applyInternalUrlCompletion,
+	getInternalUrlSuggestions,
+	type InternalUrlCallerContext,
+	isInternalUrlPrefix,
+} from "./internal-url-autocomplete";
+import {
+	applyModelMentionCompletion,
+	getModelMentionSuggestions,
+	isModelMentionPrefix,
+	type ModelMentionCandidateSource,
+} from "./model-mention-autocomplete";
+import { subsequenceMatch, subsequenceScore } from "../autocomplete";
+
+let emojiAutocompleteEnabled = true;
+
+/** Set the process-wide emoji completion preference. */
+export function setEmojiAutocompleteEnabled(enabled: boolean): void {
+	emojiAutocompleteEnabled = enabled;
+}
+
+interface PromptActionDefinition {
+	id: string;
+	label: string;
+	description: string;
+	keywords: string[];
+	execute: (prefix: string) => void;
+}
+
+interface PromptActionAutocompleteItem extends AutocompleteItem {
+	actionId: string;
+	execute: (prefix: string) => void;
+}
+
+interface PromptActionAutocompleteOptions {
+	commands: SlashCommand[];
+	basePath: string;
+	/** Usage count per command name for frequency-ranked slash completions. */
+	commandUsage?: (name: string) => number;
+	/** Read the receiving session at lookup time, following focus and session replacement. */
+	internalUrlCaller?: () => InternalUrlCallerContext;
+	/** Session-scoped models available for `^` mentions. */
+	modelMentions?: ModelMentionCandidateSource;
+	keybindings: KeybindingsManager;
+	copyCurrentLine: () => void;
+	copyPrompt: () => void;
+	undo: (prefix: string) => void;
+	moveCursorToMessageEnd: () => void;
+	moveCursorToMessageStart: () => void;
+	moveCursorToLineStart: () => void;
+	moveCursorToLineEnd: () => void;
+}
+
+function isPromptActionItem(item: AutocompleteItem): item is PromptActionAutocompleteItem {
+	return "actionId" in item && "execute" in item && typeof item.execute === "function";
+}
+
+function getPromptActionPrefix(textBeforeCursor: string): string | null {
+	const hashIndex = textBeforeCursor.lastIndexOf("#");
+	if (hashIndex === -1) return null;
+
+	const query = textBeforeCursor.slice(hashIndex + 1);
+	if (/[\s]/.test(query)) {
+		return null;
+	}
+
+	return textBeforeCursor.slice(hashIndex);
+}
+
+function applyGithubRefCompletion(
+	lines: string[],
+	cursorLine: number,
+	cursorCol: number,
+	item: AutocompleteItem,
+	prefix: string,
+): { lines: string[]; cursorLine: number; cursorCol: number } | null {
+	if (!getGithubRefContext(prefix)) return null;
+	const scheme: "pr" | "issue" | null = item.value.startsWith("pr://")
+		? "pr"
+		: item.value.startsWith("issue://")
+			? "issue"
+			: null;
+	if (!scheme) return { lines, cursorLine, cursorCol };
+
+	const currentLine = lines[cursorLine] || "";
+	const liveContext = getGithubRefContext(currentLine.slice(0, cursorCol));
+	if (!liveContext || (liveContext.qualifier && liveContext.qualifier !== scheme)) {
+		return { lines, cursorLine, cursorCol };
+	}
+
+	return applyInternalUrlCompletion(
+		lines,
+		cursorLine,
+		cursorCol,
+		{ ...item, value: `${scheme}://${liveContext.number}` },
+		liveContext.prefix,
+	);
+}
+
+export class PromptActionAutocompleteProvider implements AutocompleteProvider {
+	#commands: SlashCommand[];
+	#baseProvider: CombinedAutocompleteProvider;
+	#actions: PromptActionDefinition[];
+	#internalUrlCaller: () => InternalUrlCallerContext;
+	#modelMentions: ModelMentionCandidateSource | undefined;
+
+	constructor(
+		commands: SlashCommand[],
+		basePath: string,
+		actions: PromptActionDefinition[],
+		commandUsage?: (name: string) => number,
+		internalUrlCaller?: () => InternalUrlCallerContext,
+		modelMentions?: ModelMentionCandidateSource,
+	) {
+		this.#commands = commands;
+		this.#baseProvider = new CombinedAutocompleteProvider(commands, basePath, { commandUsage });
+		this.#internalUrlCaller = internalUrlCaller ?? (() => ({ cwd: basePath }));
+		this.#modelMentions = modelMentions;
+		this.#actions = actions;
+	}
+
+	async getSuggestions(
+		lines: string[],
+		cursorLine: number,
+		cursorCol: number,
+		signal?: AbortSignal,
+	): Promise<{ items: AutocompleteItem[]; prefix: string } | null> {
+		if (signal?.aborted) return null;
+		const currentLine = lines[cursorLine] || "";
+		const textBeforeCursor = currentLine.slice(0, cursorCol);
+		const leadingSlashStart = findLeadingSlashCommandStart(textBeforeCursor);
+		const hasPromptTextBeforeCursorLine = lines.slice(0, cursorLine).some(line => (line || "").trim() !== "");
+		const commandText =
+			leadingSlashStart !== null && !hasPromptTextBeforeCursorLine
+				? textBeforeCursor.slice(leadingSlashStart)
+				: null;
+		const spaceIndex = commandText?.indexOf(" ") ?? -1;
+		if (commandText !== null && spaceIndex !== -1) {
+			const commandName = commandText.slice(1, spaceIndex);
+			const command = this.#commands.find(cmd => cmd.name === commandName || cmd.aliases?.includes(commandName));
+			if (command && (!("allowArgs" in command) || command.allowArgs !== false)) {
+				const argumentSuggestions = await this.#baseProvider.getSuggestions(lines, cursorLine, cursorCol, signal);
+				if (argumentSuggestions) return argumentSuggestions;
+				const modelMentionSuggestions = getModelMentionSuggestions(textBeforeCursor, this.#modelMentions);
+				if (modelMentionSuggestions) return modelMentionSuggestions;
+				// No slash-argument completion for this input: preserve numeric
+				// GitHub references and internal URLs while keeping prompt-action
+				// tokens such as `#copy` literal.
+				const githubRefSuggestions = getGithubRefSuggestions(textBeforeCursor);
+				if (githubRefSuggestions) return githubRefSuggestions;
+				return getInternalUrlSuggestions(textBeforeCursor, undefined, signal, this.#internalUrlCaller);
+			}
+		}
+
+		const githubRefSuggestions = getGithubRefSuggestions(textBeforeCursor);
+		if (githubRefSuggestions) return githubRefSuggestions;
+		const promptActionPrefix = getPromptActionPrefix(textBeforeCursor);
+		if (promptActionPrefix) {
+			const query = promptActionPrefix.slice(1).toLowerCase();
+			const items = this.#actions
+				.map(action => {
+					const searchable = [action.label, action.description, ...action.keywords].join(" ").toLowerCase();
+					if (!subsequenceMatch(query, searchable)) return null;
+					return {
+						value: action.label,
+						label: action.label,
+						description: action.description,
+						actionId: action.id,
+						execute: action.execute,
+						score: subsequenceScore(query, searchable),
+					} satisfies PromptActionAutocompleteItem & { score: number };
+				})
+				.filter(item => item !== null)
+				.sort((a, b) => b.score - a.score)
+				.map(({ score: _score, ...item }) => item);
+			if (items.length > 0) {
+				return { items, prefix: promptActionPrefix };
+			}
+		}
+
+		const modelMentionSuggestions = getModelMentionSuggestions(textBeforeCursor, this.#modelMentions);
+		if (modelMentionSuggestions) return modelMentionSuggestions;
+
+		const urlSuggestions = await getInternalUrlSuggestions(
+			textBeforeCursor,
+			undefined,
+			signal,
+			this.#internalUrlCaller,
+		);
+		if (urlSuggestions) return urlSuggestions;
+
+		if (emojiAutocompleteEnabled) {
+			const emojiSuggestions = getEmojiSuggestions(textBeforeCursor);
+			if (emojiSuggestions) return emojiSuggestions;
+		}
+
+		return this.#baseProvider.getSuggestions(lines, cursorLine, cursorCol, signal);
+	}
+
+	applyCompletion(
+		lines: string[],
+		cursorLine: number,
+		cursorCol: number,
+		item: AutocompleteItem,
+		prefix: string,
+	): {
+		lines: string[];
+		cursorLine: number;
+		cursorCol: number;
+		onApplied?: () => void;
+	} {
+		const githubRefCompletion = applyGithubRefCompletion(lines, cursorLine, cursorCol, item, prefix);
+		if (githubRefCompletion) return githubRefCompletion;
+		if (prefix.startsWith("#") && isPromptActionItem(item)) {
+			if (item.actionId === "undo") {
+				return {
+					lines,
+					cursorLine,
+					cursorCol,
+					onApplied: () => item.execute(prefix),
+				};
+			}
+			const currentLine = lines[cursorLine] || "";
+			const beforePrefix = currentLine.slice(0, cursorCol - prefix.length);
+			const afterCursor = currentLine.slice(cursorCol);
+			const newLines = [...lines];
+			newLines[cursorLine] = beforePrefix + afterCursor;
+			return {
+				lines: newLines,
+				cursorLine,
+				cursorCol: beforePrefix.length,
+				onApplied: () => item.execute(prefix),
+			};
+		}
+
+		if (isModelMentionPrefix(prefix)) {
+			return applyModelMentionCompletion(lines, cursorLine, cursorCol, item, prefix);
+		}
+
+		if (isInternalUrlPrefix(prefix)) {
+			return applyInternalUrlCompletion(lines, cursorLine, cursorCol, item, prefix);
+		}
+
+		if (isEmojiPrefix(prefix)) {
+			return applyEmojiCompletion(lines, cursorLine, cursorCol, item, prefix);
+		}
+		return this.#baseProvider.applyCompletion(lines, cursorLine, cursorCol, item, prefix);
+	}
+
+	getInlineHint(lines: string[], cursorLine: number, cursorCol: number): string | null {
+		return this.#baseProvider.getInlineHint?.(lines, cursorLine, cursorCol) ?? null;
+	}
+	trySyncSlashCompletion(textBeforeCursor: string): { items: AutocompleteItem[]; prefix: string } | null {
+		return this.#baseProvider.trySyncSlashCompletion?.(textBeforeCursor) ?? null;
+	}
+	trySyncInlineReplace(textBeforeCursor: string): { replaceLen: number; insert: string } | null {
+		if (!emojiAutocompleteEnabled) return null;
+		return tryEmojiInlineReplace(textBeforeCursor);
+	}
+}
+
+export function createPromptActionAutocompleteProvider(
+	options: PromptActionAutocompleteOptions,
+): PromptActionAutocompleteProvider {
+	const editorKeybindings = getKeybindings();
+	const actions: PromptActionDefinition[] = [
+		{
+			id: "copy-line",
+			label: "Copy current line",
+			description: formatKeyHints(options.keybindings.getKeys("app.clipboard.copyLine")),
+			keywords: ["copy", "line", "clipboard", "current"],
+			execute: options.copyCurrentLine,
+		},
+		{
+			id: "copy-prompt",
+			label: "Copy whole prompt",
+			description: formatKeyHints(options.keybindings.getKeys("app.clipboard.copyPrompt")),
+			keywords: ["copy", "prompt", "clipboard", "message"],
+			execute: options.copyPrompt,
+		},
+		{
+			id: "undo",
+			label: "Undo",
+			description: formatKeyHints(editorKeybindings.getKeys("tui.editor.undo")),
+			keywords: ["undo", "revert", "edit", "history"],
+			execute: options.undo,
+		},
+		{
+			id: "cursor-message-end",
+			label: "Move cursor to message end",
+			description: "Current message",
+			keywords: ["move", "cursor", "message", "end", "prompt", "last", "bottom"],
+			execute: options.moveCursorToMessageEnd,
+		},
+		{
+			id: "cursor-message-start",
+			label: "Move cursor to message start",
+			description: "Current message",
+			keywords: ["move", "cursor", "message", "start", "beginning", "prompt", "first", "top"],
+			execute: options.moveCursorToMessageStart,
+		},
+		{
+			id: "cursor-line-start",
+			label: "Move cursor to line start",
+			description: formatKeyHints(editorKeybindings.getKeys("tui.editor.cursorLineStart")),
+			keywords: ["move", "cursor", "line", "start", "beginning", "home"],
+			execute: options.moveCursorToLineStart,
+		},
+		{
+			id: "cursor-line-end",
+			label: "Move cursor to line end",
+			description: formatKeyHints(editorKeybindings.getKeys("tui.editor.cursorLineEnd")),
+			keywords: ["move", "cursor", "line", "end"],
+			execute: options.moveCursorToLineEnd,
+		},
+	];
+
+	return new PromptActionAutocompleteProvider(
+		options.commands,
+		options.basePath,
+		actions,
+		options.commandUsage,
+		options.internalUrlCaller,
+		options.modelMentions,
+	);
+}

package/src/prompt/queue-input.ts

@@ -0,0 +1,132 @@
+const QUEUE_PREFIXES: readonly string[] = ["->", "=>"];
+/** Prefix matcher shared by queue-list parsing and editor highlighting. */
+export const QUEUE_LIST_MARKER_RE = /^([\t ]*)(\d+|[A-Za-z]+)([.)])(?=[\t ]|$)/;
+const CANONICAL_ROMAN_RE = /^(?=[MDCLXVI])M{0,3}(?:CM|CD|D?C{0,3})(?:XC|XL|L?X{0,3})(?:IX|IV|V?I{0,3})$/i;
+
+interface EnumeratedItem {
+	line: number;
+	indent: string;
+	marker: string;
+	punctuation: string;
+	content: string;
+}
+
+interface EnumeratedList {
+	source: string;
+	lines: string[];
+	items: EnumeratedItem[];
+}
+
+/** Extract the message body from the `->` / `=>` yield-queue shorthand. */
+export function parseQueueShorthand(text: string): string | undefined {
+	const prefix = QUEUE_PREFIXES.find(candidate => text.startsWith(candidate));
+	return prefix ? text.slice(prefix.length).trim() : undefined;
+}
+
+function parseEnumeratedItem(line: string, lineIndex: number): EnumeratedItem | undefined {
+	const match = QUEUE_LIST_MARKER_RE.exec(line);
+	if (!match) return undefined;
+	const [matched, indent, marker, punctuation] = match;
+	if (indent === undefined || marker === undefined || punctuation === undefined) return undefined;
+	return { line: lineIndex, indent, marker, punctuation, content: line.slice(matched.length).trimStart() };
+}
+
+function decodeDecimal(marker: string): number | undefined {
+	if (!/^\d+$/.test(marker)) return undefined;
+	const value = Number(marker);
+	return Number.isSafeInteger(value) ? value : undefined;
+}
+
+function decodeRoman(marker: string): number | undefined {
+	if (!CANONICAL_ROMAN_RE.test(marker)) return undefined;
+	const values: Readonly<Record<string, number>> = {
+		I: 1,
+		V: 5,
+		X: 10,
+		L: 50,
+		C: 100,
+		D: 500,
+		M: 1000,
+	};
+	const upper = marker.toUpperCase();
+	let value = 0;
+	for (let index = 0; index < upper.length; index++) {
+		const current = values[upper[index] ?? ""];
+		if (current === undefined) return undefined;
+		const next = values[upper[index + 1] ?? ""] ?? 0;
+		value += current < next ? -current : current;
+	}
+	return value;
+}
+
+function decodeAlpha(marker: string): number | undefined {
+	if (!/^[A-Za-z]+$/.test(marker)) return undefined;
+	let value = 0;
+	for (const char of marker.toUpperCase()) {
+		value = value * 26 + char.charCodeAt(0) - 64;
+		if (!Number.isSafeInteger(value)) return undefined;
+	}
+	return value;
+}
+
+function isSequential(markers: readonly string[], decode: (marker: string) => number | undefined): boolean {
+	let previous = decode(markers[0] ?? "");
+	if (previous === undefined) return false;
+	for (let index = 1; index < markers.length; index++) {
+		const current = decode(markers[index] ?? "");
+		if (current === undefined || current !== previous + 1) return false;
+		previous = current;
+	}
+	return true;
+}
+
+function isEnumeratedSequence(items: readonly EnumeratedItem[]): boolean {
+	const markers = items.map(item => item.marker);
+	if (markers.every(marker => /^\d+$/.test(marker))) return isSequential(markers, decodeDecimal);
+	if (
+		!markers.every(marker => marker === marker.toUpperCase()) &&
+		!markers.every(marker => marker === marker.toLowerCase())
+	) {
+		return false;
+	}
+	return isSequential(markers, decodeRoman) || isSequential(markers, decodeAlpha);
+}
+
+function parseEnumeratedList(text: string): EnumeratedList | undefined {
+	const source = text.trim();
+	if (!source) return undefined;
+	const lines = source.split(/\r?\n/);
+	const first = parseEnumeratedItem(lines[0] ?? "", 0);
+	if (!first) return undefined;
+
+	const items = [first];
+	for (let lineIndex = 1; lineIndex < lines.length; lineIndex++) {
+		const item = parseEnumeratedItem(lines[lineIndex] ?? "", lineIndex);
+		if (item?.indent === first.indent) items.push(item);
+	}
+	if (items.length < 2 || items.some(item => item.punctuation !== first.punctuation) || !isEnumeratedSequence(items)) {
+		return undefined;
+	}
+	return { source, lines, items };
+}
+
+/** Whether text currently forms a sequential queue list, including an unfinished trailing item. */
+export function isQueuedMessageList(text: string): boolean {
+	return parseEnumeratedList(text) !== undefined;
+}
+
+/** Split a sequential numeric, Roman-numeral, or alphabetic list into queue entries. */
+export function splitQueuedMessages(text: string): string[] {
+	const list = parseEnumeratedList(text);
+	if (!list) {
+		const source = text.trim();
+		return source ? [source] : [];
+	}
+
+	const messages = list.items.map((item, index) => {
+		const nextLine = list.items[index + 1]?.line ?? list.lines.length;
+		return [item.content, ...list.lines.slice(item.line + 1, nextLine)].join("\n").trim();
+	});
+	while (messages.at(-1) === "") messages.pop();
+	return messages.length > 0 && messages.every(Boolean) ? messages : [list.source];
+}

package/src/prompt/skill-tokens.ts

@@ -0,0 +1,36 @@
+/**
+ * One `/skill:<name>` token delimited by whitespace or line edges. Group 1 is
+ * the leading delimiter (empty at line start), group 2 the bare skill name.
+ * Global so callers can walk every token; reset `lastIndex` before reuse.
+ */
+export const SKILL_TOKEN_RE = /(^|\s)\/skill:([^\s/]+)(?=\s|$)/g;
+
+/**
+ * Whether the (already left-trimmed) draft begins with a TUI local-execution
+ * sigil that downstream branches consume verbatim.
+ */
+function startsWithLocalExecutionPrefix(trimmedStart: string): boolean {
+	if (trimmedStart.startsWith("!")) return true;
+	if (trimmedStart.charCodeAt(0) !== 36 /* $ */) return false;
+	if (trimmedStart.charCodeAt(1) === 123 /* { */) return false;
+	const sigilLength = trimmedStart.charCodeAt(1) === 36 /* $ */ ? 2 : 1;
+	const next = trimmedStart.charCodeAt(sigilLength);
+	if (Number.isNaN(next)) return true;
+	return next === 32 /* space */ || next === 9 /* tab */ || next === 10 /* LF */ || next === 13; /* CR */
+}
+
+/**
+ * Whether `/skill:<name>` tokens in `text` are invocations rather than content
+ * belonging to another slash command or local-execution sigil.
+ */
+export function allowsSkillTokens(text: string): boolean {
+	const trimmedStart = text.trimStart();
+	if (trimmedStart.startsWith("/skill:")) return true;
+	if (trimmedStart.startsWith("/")) return false;
+	return !startsWithLocalExecutionPrefix(trimmedStart);
+}
+
+/** Whether model mentions may collapse in this draft; local execution consumes its body verbatim. */
+export function allowsModelMentions(text: string): boolean {
+	return !startsWithLocalExecutionPrefix(text.trimStart());
+}

package/src/prompt/tips.txt

@@ -0,0 +1,27 @@
+Tired of typing "keep going"? Just send a '.'
+You can /btw to ask a side question
+Use /tan to fork the current conversation into a background agent
+With default keybindings, Ctrl+D deletes the character under the cursor instead of quitting your draft — see /hotkeys for your exit key
+Find out which model you emotionally abuse the most with `omp stats`
+Try task isolation to create CoW worktrees
+Need a cheap nested model call? Use `completion(x...)`. Have a big batch of tasks? Ask clanker to use it!
+Spaghetti code? Try complaining with /omfg
+Did you know? Each kitty/tmux/cmux/zellij/wezterm split keeps its own session — `omp -c` resumes the right one
+Drop the word `ultrathink` in your message for harder multi-step reasoning — watch it glow rainbow as you type
+Say `orchestrate` in your message to drive a multi-phase task with parallel subagents — watch it glow as you type
+Say `workflowz` in your message to drive the task with parallel subagents in eval — watch it glow as you type
+Log in to several accounts of the same provider — `/login` again — and omp load-balances across them automatically
+Run `omp auth-broker serve` once and every machine pulls live tokens over the wire — refresh keys never leave the host; `omp auth-gateway` fronts it as a drop-in proxy any OpenAI-compatible client can hit
+Press alt+p (or /switch) to switch provider, and ctrl+p to cycle role models smol -> slow -> etc
+Press ctrl+r to search your prompt history and reuse a past message
+`/force read` pins the next turn to one specific tool when the model keeps reaching for the wrong one
+`/copy code` grabs the last code block to your clipboard — `/copy cmd` grabs the last shell/python command
+`/shake` rips heavy tool results out of context to reclaim tokens without a full /compact — `/shake images` drops just images
+Pair up live: `/collab` shares your session through an end-to-end encrypted relay link — a teammate runs `/join <link>` to watch tool calls stream and prompt the agent from their own omp
+Press ← ← to drill into a running or finished agent and inspect its tool calls and transcript
+Hit a Codex rate limit? `/usage reset` spends a saved reset credit to immediately restore your quota
+No native tool_calling? Inference provider botches parsing them? `PI_DIALECT=glm|kimi|anthropic…` rolls it locally for them!
+Turn on `/advisor` to attach a second model that reviews every turn and quietly injects advice
+Try starting your prompt with a ->, and writing a list (1. Do X, 2. Do Y)
+Press shift+tab to cycle through reasoning effort levels
+Lint/type errors piling up? `omp cleanse` (or /cleanse right here) hunts project diagnostics and fixes them with parallel subagents — esc cancels

package/src/prompt/tools-markdown.ts

@@ -0,0 +1,29 @@
+export interface ToolsMarkdownBindings {
+	tools: ReadonlyArray<{ description: string; name: string }>;
+	/** Tools mounted under `xd://` URLs, listed after the active set. */
+	xdevTools?: ReadonlyArray<{ name: string; summary: string }>;
+}
+
+function escapeTableCell(value: string): string {
+	return value
+		.replace(/\|/g, "\\|")
+		.replace(/\r?\n+/g, " ")
+		.trim();
+}
+
+export function buildToolsMarkdown(bindings: ToolsMarkdownBindings): string {
+	if (bindings.tools.length === 0 && !bindings.xdevTools?.length) {
+		return "No tools are currently visible to the agent.";
+	}
+
+	const rows: string[] = [];
+	for (const tool of bindings.tools) {
+		const description = escapeTableCell(tool.description) || "No description provided.";
+		rows.push(`| \`${tool.name}\` | ${description} |`);
+	}
+	for (const mounted of bindings.xdevTools ?? []) {
+		rows.push(`| \`xd://${mounted.name}\` | ${escapeTableCell(mounted.summary) || "No description provided."} |`);
+	}
+
+	return ["| Tool | Description |", "|------|-------------|", ...rows].join("\n");
+}

package/src/prompt/ultrathink.ts

@@ -0,0 +1,26 @@
+import { createGradientHighlighter, type KeywordHighlighter } from "./gradient-highlight";
+import { magicKeywordRegex } from "./magic-keyword-boundary";
+import { keywordInProse } from "./markdown-prose";
+
+const ULTRATHINK_WORD = magicKeywordRegex("ultrathink");
+
+/**
+ * Whether `text` contains the standalone keyword "ultrathink" (lowercase,
+ * prose-delimited) in prose — never inside a code block, inline code span,
+ * or XML/HTML section.
+ */
+export function containsUltrathink(text: string): boolean {
+	return keywordInProse(text, ULTRATHINK_WORD);
+}
+
+/**
+ * Rainbow-highlight every standalone "ultrathink" in `text` for editor display.
+ * Sweeps red→violet (hue 0..330), stopping short of the wrap back to red so the
+ * gradient resolves smoothly regardless of casing or match length.
+ */
+export const highlightUltrathink: KeywordHighlighter = createGradientHighlighter({
+	probe: /ultrathink/,
+	highlight: magicKeywordRegex("ultrathink", "g"),
+	stops: 14,
+	hue: t => t * 330,
+});

package/src/prompt/usage-amounts.ts

@@ -0,0 +1,99 @@
+import { resolveUsedFraction, type UsageLimit } from "@oh-my-pi/pi-ai/usage";
+
+/**
+ * Formatting for usage limits that carry an absolute amount but no fraction,
+ * shared by the `/usage` TUI report and the fullscreen dashboard so both
+ * surfaces agree on what a bucket is worth.
+ *
+ * Providers report one of two one-sided shapes: spend-to-date with no
+ * allowance (`used` only), or a prepaid balance with no total (`remaining`
+ * only). Neither can fill a quota bar, so each renders as text instead.
+ */
+function isAbsoluteUnit(limit: UsageLimit): boolean {
+	return limit.amount.unit !== "percent" && limit.amount.unit !== "unknown";
+}
+
+export function isUsedOnlyAbsoluteAmount(limit: UsageLimit): boolean {
+	const amount = limit.amount;
+	return (
+		isAbsoluteUnit(limit) &&
+		amount.used !== undefined &&
+		Number.isFinite(amount.used) &&
+		amount.limit === undefined &&
+		amount.remaining === undefined &&
+		resolveUsedFraction(limit) === undefined
+	);
+}
+
+export function isRemainingOnlyAbsoluteAmount(limit: UsageLimit): boolean {
+	const amount = limit.amount;
+	return (
+		isAbsoluteUnit(limit) &&
+		amount.remaining !== undefined &&
+		Number.isFinite(amount.remaining) &&
+		amount.limit === undefined &&
+		amount.used === undefined &&
+		resolveUsedFraction(limit) === undefined
+	);
+}
+
+function formatQuantity(value: number, unit: UsageLimit["amount"]["unit"], suffix: string): string {
+	if (unit === "usd") return `$${value.toFixed(2)} ${suffix}`;
+	const formatted = new Intl.NumberFormat("en-US", { notation: "compact", maximumFractionDigits: 1 }).format(value);
+	return `${formatted} ${unit} ${suffix}`;
+}
+
+/**
+ * Total the prepaid headroom a set of limits actually represents.
+ *
+ * A `scope.shared` limit is one account-wide pool observed once per stored
+ * credential, so N keys on the same account yield N identical rows that must
+ * collapse to a single value — summing them would claim several times the
+ * credits a single request can draw on. Limits without the flag are genuinely
+ * per-account and do add up. Returns `undefined` unless every limit is
+ * remaining-only and agrees on a unit, so mixed buckets fall through to the
+ * caller's own handling.
+ */
+export function totalRemainingOnly(
+	limits: readonly UsageLimit[],
+): { value: number; unit: UsageLimit["amount"]["unit"] } | undefined {
+	const first = limits[0];
+	if (first === undefined || !limits.every(isRemainingOnlyAbsoluteAmount)) return undefined;
+	const unit = first.amount.unit;
+	if (!limits.every(limit => limit.amount.unit === unit)) return undefined;
+
+	let total = 0;
+	let sharedMax: number | undefined;
+	for (const limit of limits) {
+		const remaining = limit.amount.remaining ?? 0;
+		if (limit.scope.shared === true) {
+			sharedMax = sharedMax === undefined ? remaining : Math.max(sharedMax, remaining);
+			continue;
+		}
+		total += remaining;
+	}
+	return { value: total + (sharedMax ?? 0), unit };
+}
+
+/** `"100 credits left"` for a bucket of remaining-only limits, else `undefined`. */
+export function formatRemainingOnlyTotal(limits: readonly UsageLimit[]): string | undefined {
+	const total = totalRemainingOnly(limits);
+	return total === undefined ? undefined : formatQuantity(total.value, total.unit, "left");
+}
+
+/**
+ * Text for a bucket no quota bar can draw: spend-to-date or prepaid headroom.
+ * Used-only limits report the worst (highest) spend; remaining-only limits go
+ * through {@link totalRemainingOnly} so shared pools are not double-counted.
+ */
+export function formatAbsoluteOnlyAmount(limits: readonly UsageLimit[]): string | undefined {
+	const first = limits[0];
+	if (first === undefined) return undefined;
+	if (limits.every(isUsedOnlyAbsoluteAmount)) {
+		const unit = first.amount.unit;
+		if (!limits.every(limit => limit.amount.unit === unit)) return undefined;
+		const used = limits.reduce((max, limit) => Math.max(max, limit.amount.used ?? 0), 0);
+		return formatQuantity(used, unit, "used");
+	}
+	return formatRemainingOnlyTotal(limits);
+}