@oh-my-pi/pi-coding-agent 16.1.23 → 16.2.1

package/src/modes/components/move-overlay.ts

@@ -0,0 +1,282 @@
+/**
+ * `/move` overlay: a path input with live directory autocomplete.
+ *
+ * Rendered as a centered modal via `showHookCustom(..., { overlay: true })`.
+ * The user types a path, Tab autocomtes the highlighted directory, and Enter
+ * confirms — yielding the resolved directory string (or `undefined` on cancel).
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { type Component, CURSOR_MARKER, type Focusable, Key, matchesKey } from "@oh-my-pi/pi-tui";
+import { theme } from "../theme/theme";
+import { matchesSelectCancel, matchesSelectDown, matchesSelectUp } from "../utils/keybinding-matchers";
+import { bottomBorder, row, topBorder } from "./overlay-box";
+
+export interface MoveOverlayResult {
+	directory: string;
+}
+
+interface DirEntry {
+	/** Full absolute path. */
+	value: string;
+	/** Display label (basename + trailing slash). */
+	label: string;
+}
+
+const MAX_RESULTS = 15;
+const OVERLAY_WIDTH = 68;
+
+/** TTL for the directory listing cache (ms). */
+const DIR_CACHE_TTL = 500;
+const dirCache = new Map<string, { time: number; entries: string[] }>();
+
+function readDirCached(dir: string): string[] {
+	const now = Date.now();
+	const cached = dirCache.get(dir);
+	if (cached && now - cached.time < DIR_CACHE_TTL) return cached.entries;
+	try {
+		const entries = fs.readdirSync(dir);
+		dirCache.set(dir, { time: now, entries });
+		return entries;
+	} catch {
+		return [];
+	}
+}
+
+function printableInput(data: string): string {
+	const withoutPasteEnvelope = data.replaceAll("\x1b[200~", "").replaceAll("\x1b[201~", "");
+	if (withoutPasteEnvelope.includes("\x1b")) return "";
+	return Array.from(withoutPasteEnvelope)
+		.filter(ch => {
+			const code = ch.codePointAt(0);
+			return code !== undefined && code >= 32 && code !== 0x7f;
+		})
+		.join("");
+}
+
+/** Resolve a user-typed path (`~`, absolute, or relative to `cwd`) to an absolute path. */
+export function resolveMovePath(input: string, cwd: string): string {
+	const trimmed = input.trim();
+	if (trimmed === "~") return os.homedir();
+	if (trimmed.startsWith("~/")) return path.join(os.homedir(), trimmed.slice(2));
+	if (path.isAbsolute(trimmed)) return path.normalize(trimmed);
+	return path.resolve(cwd, trimmed);
+}
+
+/** If `input` resolves to an existing directory, return it; otherwise `null`. */
+export function resolveExistingDirectory(input: string, cwd: string): string | null {
+	const resolved = resolveMovePath(input, cwd);
+	try {
+		return fs.statSync(resolved).isDirectory() ? resolved : null;
+	} catch {
+		return null;
+	}
+}
+
+function listChildDirectories(dirPath: string, max: number, includeHidden = false): DirEntry[] {
+	const results: DirEntry[] = [];
+	const names = readDirCached(dirPath);
+	for (const name of names) {
+		if (results.length >= max) break;
+		if (!includeHidden && name.startsWith(".")) continue;
+		const full = path.join(dirPath, name);
+		try {
+			if (!fs.statSync(full).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		results.push({ value: full, label: `${name}/` });
+	}
+	results.sort((a, b) => a.label.localeCompare(b.label));
+	return results;
+}
+
+function searchDirectories(prefix: string, cwd: string, max: number): DirEntry[] {
+	if (!prefix) return listChildDirectories(cwd, max);
+
+	// Split into base dir + query so dot-prefixed segments can reveal hidden directories.
+	const norm = prefix.replace(/\\/g, "/");
+	const slashIdx = norm.lastIndexOf("/");
+	let baseDir: string;
+	let query: string;
+	if (slashIdx === -1) {
+		baseDir = cwd;
+		query = prefix;
+	} else {
+		const base = norm.slice(0, slashIdx + 1);
+		query = norm.slice(slashIdx + 1);
+		baseDir = resolveMovePath(base, cwd);
+	}
+
+	const includeHidden = query.startsWith(".");
+
+	// If the prefix already resolves to an existing directory, list its children.
+	// A dot-prefixed query is treated as a filter so hidden directories become reachable.
+	const resolved = includeHidden ? null : resolveExistingDirectory(prefix, cwd);
+	if (resolved) return listChildDirectories(resolved, max);
+
+	const lower = query.toLowerCase();
+	const results: DirEntry[] = [];
+	const names = readDirCached(baseDir);
+	for (const name of names) {
+		if (results.length >= max) break;
+		if (!includeHidden && name.startsWith(".")) continue;
+		const full = path.join(baseDir, name);
+		try {
+			if (!fs.statSync(full).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		if (!query || name.toLowerCase().includes(lower)) {
+			results.push({ value: full, label: `${name}/` });
+		}
+	}
+	return results;
+}
+
+/**
+ * Overlay component for `/move`: a single-line path input with a live-filtered
+ * list of matching directories. Tab accepts the highlighted suggestion; Enter
+ * confirms the current input (or the highlighted suggestion if the input is
+ * empty); Escape cancels.
+ */
+export class MoveOverlay implements Component, Focusable {
+	#focused = false;
+	#input = "";
+	#cursor = 0;
+	#selectedIndex = 0;
+	#results: DirEntry[] = [];
+	#cwd: string;
+	#done: (result: MoveOverlayResult | undefined) => void;
+
+	constructor(cwd: string, done: (result: MoveOverlayResult | undefined) => void) {
+		this.#cwd = cwd;
+		this.#done = done;
+		// Warm the cache for the current directory so the first keystroke is instant.
+		readDirCached(cwd);
+		this.#updateResults();
+	}
+
+	get focused(): boolean {
+		return this.#focused;
+	}
+
+	set focused(value: boolean) {
+		this.#focused = value;
+	}
+
+	handleInput(data: string): void {
+		if (matchesSelectCancel(data) || matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c"))) {
+			this.#done(undefined);
+			return;
+		}
+		if (matchesKey(data, Key.enter) || matchesKey(data, Key.return)) {
+			this.#confirm();
+			return;
+		}
+		if (matchesSelectUp(data) || matchesKey(data, Key.up)) {
+			if (this.#results.length > 0) this.#selectedIndex = Math.max(0, this.#selectedIndex - 1);
+			return;
+		}
+		if (matchesSelectDown(data) || matchesKey(data, Key.down)) {
+			if (this.#results.length > 0)
+				this.#selectedIndex = Math.min(this.#results.length - 1, this.#selectedIndex + 1);
+			return;
+		}
+		if (matchesKey(data, Key.tab)) {
+			const selected = this.#results[this.#selectedIndex];
+			if (selected) {
+				this.#input = selected.value;
+				this.#cursor = this.#input.length;
+				this.#selectedIndex = 0;
+				this.#updateResults();
+			}
+			return;
+		}
+		if (matchesKey(data, Key.left)) {
+			this.#cursor = Math.max(0, this.#cursor - 1);
+			return;
+		}
+		if (matchesKey(data, Key.right)) {
+			this.#cursor = Math.min(this.#input.length, this.#cursor + 1);
+			return;
+		}
+		if (matchesKey(data, Key.backspace) && this.#cursor > 0) {
+			this.#input = this.#input.slice(0, this.#cursor - 1) + this.#input.slice(this.#cursor);
+			this.#cursor--;
+			this.#selectedIndex = 0;
+			this.#updateResults();
+			return;
+		}
+		const text = printableInput(data);
+		if (text.length > 0) {
+			this.#input = this.#input.slice(0, this.#cursor) + text + this.#input.slice(this.#cursor);
+			this.#cursor += text.length;
+			this.#selectedIndex = 0;
+			this.#updateResults();
+		}
+	}
+
+	render(_width: number): readonly string[] {
+		const w = OVERLAY_WIDTH;
+		const lines: string[] = [];
+
+		lines.push(topBorder(w, "Move to directory"));
+		lines.push(row(this.#renderInput(), w));
+		lines.push(row("", w));
+
+		if (this.#results.length === 0 && this.#input.length > 0) {
+			lines.push(row(theme.fg("dim", "No matching directories"), w));
+		} else {
+			for (let i = 0; i < Math.min(this.#results.length, MAX_RESULTS); i++) {
+				const item = this.#results[i]!;
+				const selected = i === this.#selectedIndex;
+				const marker = selected ? theme.fg("accent", "▶ ") : "  ";
+				const label = selected ? theme.fg("accent", item.label) : theme.fg("text", item.label);
+				lines.push(row(`${marker}${label}`, w));
+			}
+		}
+
+		lines.push(row("", w));
+		lines.push(row(theme.fg("dim", "Type to filter · ↑↓ navigate · Tab accept · Enter confirm · Esc cancel"), w));
+		lines.push(bottomBorder(w));
+		return lines;
+	}
+
+	invalidate(): void {}
+
+	#renderInput(): string {
+		const prompt = theme.fg("dim", "Path: ");
+		if (this.#input.length === 0) {
+			const placeholder = theme.fg("dim", "Type a directory path…");
+			const marker = this.#focused ? CURSOR_MARKER : "";
+			return `${prompt}${placeholder}${marker}\x1b[7m \x1b[27m`;
+		}
+		const before = this.#input.slice(0, this.#cursor);
+		const cursorChar = this.#cursor < this.#input.length ? this.#input[this.#cursor] : " ";
+		const after = this.#input.slice(this.#cursor + 1);
+		const marker = this.#focused ? CURSOR_MARKER : "";
+		return `${prompt}${before}${marker}\x1b[7m${cursorChar}\x1b[27m${after}`;
+	}
+
+	#updateResults(): void {
+		this.#results = searchDirectories(this.#input, this.#cwd, MAX_RESULTS + 5);
+		if (this.#selectedIndex >= this.#results.length) {
+			this.#selectedIndex = Math.max(0, this.#results.length - 1);
+		}
+	}
+
+	#confirm(): void {
+		const selected = this.#results[this.#selectedIndex];
+		if (selected) {
+			this.#done({ directory: selected.value });
+			return;
+		}
+		if (this.#input.trim().length > 0) {
+			this.#done({ directory: this.#input.trim() });
+			return;
+		}
+		this.#done(undefined);
+	}
+}

package/src/modes/components/plan-review-overlay.ts

@@ -23,7 +23,7 @@ import {
 	Markdown,
 	type MarkdownTheme,
 	matchesKey,
-	parseSgrMouse,
+	routeSgrMouseInput,
 	ScrollView,
 	truncateToWidth,
 	visibleWidth,
@@ -333,42 +333,42 @@ export class PlanReviewOverlay implements Component {
 	 * the body.
 	 */
 	#handleMouse(data: string): boolean {
-		const event = parseSgrMouse(data);
-		if (!event) return false;
-		if (event.wheel !== null) {
-			// Scroll wheel: three rows per notch.
-			this.#scrollView.scroll(event.wheel * 3);
-			return true;
-		}
-		if (event.release) return true;
-		if (event.motion) {
-			// Motion (hover or drag): light up the option row under the pointer so a
-			// mouse user gets the same affordance the keyboard cursor gives. Any
-			// non-option row clears the highlight.
-			this.#setHoveredOption(this.#optionClickRows.get(event.row));
-			return true;
-		}
-		if (!event.leftClick) return true;
-		const optionIndex = this.#optionClickRows.get(event.row);
-		if (optionIndex !== undefined) {
-			if (!this.#disabled.has(optionIndex)) {
-				this.#focus = "actions";
-				this.#selectedIndex = optionIndex;
-				this.#confirmSelection();
+		return routeSgrMouseInput(data, event => {
+			if (event.wheel !== null) {
+				// Scroll wheel: three rows per notch.
+				this.#scrollView.scroll(event.wheel * 3);
+				return true;
+			}
+			if (event.release) return true;
+			if (event.motion) {
+				// Motion (hover or drag): light up the option row under the pointer so a
+				// mouse user gets the same affordance the keyboard cursor gives. Any
+				// non-option row clears the highlight.
+				this.#setHoveredOption(this.#optionClickRows.get(event.row));
+				return true;
+			}
+			if (!event.leftClick) return true;
+			const optionIndex = this.#optionClickRows.get(event.row);
+			if (optionIndex !== undefined) {
+				if (!this.#disabled.has(optionIndex)) {
+					this.#focus = "actions";
+					this.#selectedIndex = optionIndex;
+					this.#confirmSelection();
+				}
+				return true;
+			}
+			const tocPos = this.#tocClickRows.get(event.row);
+			if (tocPos !== undefined && event.col < this.#sidebarClickMaxCol) {
+				this.#focus = "toc";
+				this.#tocCursor = tocPos;
+				this.#scrubBodyToToc();
+				return true;
+			}
+			if (this.#bodyClickRows.has(event.row)) {
+				this.#setFocus("body");
 			}
 			return true;
-		}
-		const tocPos = this.#tocClickRows.get(event.row);
-		if (tocPos !== undefined && event.col < this.#sidebarClickMaxCol) {
-			this.#focus = "toc";
-			this.#tocCursor = tocPos;
-			this.#scrubBodyToToc();
-			return true;
-		}
-		if (this.#bodyClickRows.has(event.row)) {
-			this.#setFocus("body");
-		}
-		return true;
+		});
 	}
 
 	/** Set the hovered option from a hit-tested row, ignoring disabled rows and

package/src/modes/components/plugin-selector.ts

@@ -4,9 +4,10 @@
  * Shows available plugins from all configured marketplaces in a SelectList.
  * Selecting a plugin triggers installation. Esc cancels.
  */
-import { Container, type SelectItem, SelectList } from "@oh-my-pi/pi-tui";
+import { Container, type SelectItem, SelectList, type SgrMouseEvent } from "@oh-my-pi/pi-tui";
 import { getSelectListTheme } from "../theme/theme";
 import { DynamicBorder } from "./dynamic-border";
+import { routeSelectListMouseWithTopBorder } from "./select-list-mouse-routing";
 
 export interface PluginSelectorCallbacks {
 	onSelect: (pluginName: string, marketplace: string, scope?: "user" | "project") => void;
@@ -82,6 +83,10 @@ export class PluginSelectorComponent extends Container {
 	getSelectList(): SelectList {
 		return this.#selectList;
 	}
+
+	routeMouse(event: SgrMouseEvent, line: number, col: number): void {
+		routeSelectListMouseWithTopBorder(this.#selectList, event, line, col);
+	}
 }
 
 function splitPluginId(id: string): [string, string, "user" | "project" | undefined] | [null, null, null] {

package/src/modes/components/queue-mode-selector.ts

@@ -1,6 +1,7 @@
-import { Container, type SelectItem, SelectList } from "@oh-my-pi/pi-tui";
+import { Container, type SelectItem, SelectList, type SgrMouseEvent } from "@oh-my-pi/pi-tui";
 import { getSelectListTheme } from "../../modes/theme/theme";
 import { DynamicBorder } from "./dynamic-border";
+import { routeSelectListMouseWithTopBorder } from "./select-list-mouse-routing";
 
 /**
  * Component that renders a queue mode selector with borders
@@ -53,4 +54,8 @@ export class QueueModeSelectorComponent extends Container {
 	getSelectList(): SelectList {
 		return this.#selectList;
 	}
+
+	routeMouse(event: SgrMouseEvent, line: number, col: number): void {
+		routeSelectListMouseWithTopBorder(this.#selectList, event, line, col);
+	}
 }

package/src/modes/components/select-list-mouse-routing.ts

@@ -0,0 +1,35 @@
+import type { SelectList, SgrMouseEvent } from "@oh-my-pi/pi-tui";
+
+interface RoutableSelectList {
+	routeMouse?: (event: SgrMouseEvent, line: number, col: number) => void;
+	handleWheel(delta: -1 | 1): void;
+	hitTest(line: number): number | undefined;
+	setHoverIndex(index: number | null): void;
+	clickItem(index: number): void;
+}
+
+export function routeSelectListMouseWithTopBorder(
+	selectList: SelectList,
+	event: SgrMouseEvent,
+	line: number,
+	col: number,
+): void {
+	const localLine = line - 1;
+	const target = selectList as RoutableSelectList;
+	if (typeof target.routeMouse === "function") {
+		target.routeMouse(event, localLine, col);
+		return;
+	}
+	if (event.wheel !== null) {
+		target.handleWheel(event.wheel);
+		return;
+	}
+	const index = target.hitTest(localLine);
+	if (event.motion) {
+		target.setHoverIndex(index ?? null);
+		return;
+	}
+	if (event.leftClick && index !== undefined) {
+		target.clickItem(index);
+	}
+}

package/src/modes/components/session-selector.ts

@@ -5,8 +5,8 @@ import {
 	Input,
 	matchesKey,
 	padding,
-	parseSgrMouse,
 	replaceTabs,
+	routeSgrMouseInput,
 	ScrollView,
 	Spacer,
 	Text,
@@ -726,15 +726,16 @@ export class SessionSelectorComponent extends Container {
 	 */
 	#handleMouse(data: string): void {
 		if (this.#confirmationDialog) return;
-		const event = parseSgrMouse(data);
-		if (!event) return;
-		if (event.wheel !== null) {
-			this.#sessionList.handleWheel(event.wheel);
-			return;
-		}
-		if (!event.leftClick || event.row >= this.#footerStart) return;
-		const index = this.#sessionList.hitTestSession(event.row - this.#listLineOffset);
-		if (index !== undefined) this.#sessionList.selectAndConfirm(index);
+		routeSgrMouseInput(data, event => {
+			if (event.wheel !== null) {
+				this.#sessionList.handleWheel(event.wheel);
+				return true;
+			}
+			if (!event.leftClick || event.row >= this.#footerStart) return true;
+			const index = this.#sessionList.hitTestSession(event.row - this.#listLineOffset);
+			if (index !== undefined) this.#sessionList.selectAndConfirm(index);
+			return true;
+		});
 	}
 
 	getSessionList(): SessionList {

package/src/modes/components/settings-defs.ts

@@ -68,7 +68,16 @@ export interface TextInputSettingDef extends BaseSettingDef {
 	type: "text";
 }
 
-export type SettingDef = BooleanSettingDef | EnumSettingDef | SubmenuSettingDef | TextInputSettingDef;
+export interface ProviderLimitsSettingDef extends BaseSettingDef {
+	type: "providerLimits";
+}
+
+export type SettingDef =
+	| BooleanSettingDef
+	| EnumSettingDef
+	| SubmenuSettingDef
+	| TextInputSettingDef
+	| ProviderLimitsSettingDef;
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Condition Functions
@@ -170,6 +179,10 @@ function pathToSettingDef(path: SettingPath): SettingDef | null {
 		return { ...base, type: "text" };
 	}
 
+	if (schemaType === "record") {
+		return path === "providers.maxInFlightRequests" ? { ...base, type: "providerLimits" } : null;
+	}
+
 	return null;
 }