pi-atuin 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 slahser
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,70 @@
+<div align="center">
+
+<img src="https://raw.githubusercontent.com/RealAlexandreAI/pi-atuin/main/screenshot.png" alt="pi-atuin preview" width="100%" />
+
+# pi-atuin
+
+**Atuin-style fuzzy history search for [Pi](https://github.com/earendil-works/pi-coding-agent)**
+
+Press ↑ to search previous prompts with fuzzy matching. Backed by atuin DB + local JSONL.
+
+</div>
+
+---
+
+## Install
+
+```bash
+pi install npm:pi-atuin
+```
+
+Or from source:
+
+```bash
+git clone https://github.com/RealAlexandreAI/pi-atuin.git
+cd pi-atuin && pi install .
+```
+
+## Setup
+
+### Full atuin integration (recommended)
+
+```bash
+# Install atuin (if not already)
+curl --proto '=https' --tlsv1.2 -LsSf https://setup.atuin.sh | sh
+
+# Register / login
+atuin register -u <username> -e <email>
+
+# Install pi hook (tracks bash commands in atuin)
+atuin hook install pi
+```
+
+With this, pi prompts and bash commands sync bidirectionally to atuin DB. Search in either pi or your shell.
+
+### JSONL-only (no atuin)
+
+No setup needed. History stored in `~/.pi/agent/pi-history.jsonl`.
+
+## Usage
+
+1. Press **↑** when your input is empty (or cursor is on the first line)
+2. Type to fuzzy-filter
+3. **↑↓** to navigate, **Enter** to select, **Esc** to cancel
+
+All pi prompts are recorded automatically. Supports bash, zsh, and fish.
+
+## Privacy
+
+- History file permissions: `600` (owner-only)
+- Max 1,000 entries, auto-trimmed
+- Atuin calls use `execFile` (no shell injection)
+- No hardcoded credentials or keys
+
+## License
+
+MIT
+
+---
+
+Built for [Pi Coding Agent](https://github.com/earendil-works/pi-coding-agent). Inspired by [atuin](https://github.com/atuinsh/atuin).

package/fuzzy-match.ts

@@ -0,0 +1,103 @@
+/**
+ * Simple fuzzy matching — no external dependencies.
+ *
+ * Returns a score and the matched character indices for highlight rendering.
+ * Higher score = better match.
+ */
+
+export interface FuzzyResult {
+	score: number;
+	indices: number[];
+}
+
+/**
+ * Match `query` against `target` (case-insensitive).
+ * Returns `null` if no match, otherwise a score and matched indices.
+ */
+export function fuzzyMatch(query: string, target: string): FuzzyResult | null {
+	if (!query) return { score: 1, indices: [] };
+
+	const q = query.toLowerCase();
+	const t = target.toLowerCase();
+
+	// Exact substring match — highest priority
+	const substringIdx = t.indexOf(q);
+	if (substringIdx !== -1) {
+		const indices = Array.from({ length: q.length }, (_, i) => substringIdx + i);
+		let score = 1000 + q.length;
+		if (substringIdx === 0) {
+			score += 100; // starts at beginning
+		} else if (/[\s_\-/]/.test(target[substringIdx - 1])) {
+			score += 50; // starts at word boundary
+		}
+		return { score, indices };
+	}
+
+	// Fuzzy character match — characters in order, not necessarily contiguous
+	const indices: number[] = [];
+	let qi = 0;
+	let lastMatchIdx = -1;
+	let consecutiveBonus = 0;
+	let score = 0;
+
+	for (let ti = 0; ti < t.length && qi < q.length; ti++) {
+		if (t[ti] === q[qi]) {
+			indices.push(ti);
+
+			// Position bonus (earlier = better)
+			score += Math.max(0, 10 - ti);
+
+			// Consecutive match bonus
+			if (lastMatchIdx === ti - 1) {
+				consecutiveBonus += 5;
+			} else {
+				consecutiveBonus = 0;
+			}
+
+			// Word boundary bonus (after space, dash, underscore, slash)
+			if (ti === 0 || /[ _\-/]/.test(target[ti - 1])) {
+				score += 15;
+			}
+
+			lastMatchIdx = ti;
+			qi++;
+		}
+	}
+
+	// Not all query characters matched
+	if (qi < q.length) return null;
+
+	score += consecutiveBonus + q.length * 2;
+
+	return { score, indices };
+}
+
+/**
+ * Sort and filter items by fuzzy match against query.
+ * Returns items in descending score order.
+ */
+export function fuzzySearch<T>(
+	query: string,
+	items: T[],
+	getText: (item: T) => string,
+	limit = 50,
+): Array<{ item: T; result: FuzzyResult }> {
+	if (!query) {
+		return items.slice(0, limit).map((item) => ({
+			item,
+			result: { score: 1, indices: [] },
+		}));
+	}
+
+	const scored: Array<{ item: T; result: FuzzyResult }> = [];
+
+	for (const item of items) {
+		const result = fuzzyMatch(query, getText(item));
+		if (result) {
+			scored.push({ item, result });
+		}
+	}
+
+	scored.sort((a, b) => b.result.score - a.result.score);
+	return scored.slice(0, limit);
+}

package/history-store.ts

@@ -0,0 +1,215 @@
+/**
+ * History storage layer — reads from atuin DB (if installed) and a local JSONL file.
+ */
+
+import { readFile, writeFile, appendFile, mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { fuzzySearch } from "./fuzzy-match.js";
+
+const execFileAsync = promisify(execFile);
+
+const JSONL_PATH = join(homedir(), ".pi", "agent", "pi-history.jsonl");
+const ATUIN_TIMEOUT_MS = 5_000;
+const MAX_ENTRIES = 1000;
+
+export interface HistoryEntry {
+	id: string;
+	text: string;
+	timestamp: number;
+	cwd?: string;
+	source: "atuin" | "pi";
+}
+
+let writeQueue: Promise<void> = Promise.resolve();
+
+// ---------------------------------------------------------------------------
+// JSONL persistence
+// ---------------------------------------------------------------------------
+
+async function ensureDir(): Promise<void> {
+	const dir = join(homedir(), ".pi", "agent");
+	await mkdir(dir, { recursive: true, mode: 0o700 });
+}
+
+export async function addEntry(
+	text: string,
+	cwd?: string,
+	sessionId?: string,
+): Promise<void> {
+	const entry: HistoryEntry = {
+		id: `pi-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+		text,
+		timestamp: Date.now(),
+		cwd,
+		source: "pi",
+	};
+
+	const line = JSON.stringify(entry) + "\n";
+
+	writeQueue = writeQueue.then(async () => {
+		await ensureDir();
+		await appendFile(JSONL_PATH, line, { encoding: "utf8", mode: 0o600 });
+		// Trim old entries if exceeding limit
+		await trimOldEntries();
+	});
+
+	await writeQueue;
+}
+
+async function trimOldEntries(): Promise<void> {
+	try {
+		const raw = await readFile(JSONL_PATH, "utf8");
+		const lines = raw.split("\n").filter((l) => l.trim());
+		if (lines.length <= MAX_ENTRIES) return;
+		// Keep the most recent MAX_ENTRIES
+		const trimmed = lines.slice(lines.length - MAX_ENTRIES);
+		await writeFile(JSONL_PATH, trimmed.join("\n") + "\n", { encoding: "utf8", mode: 0o600 });
+	} catch {
+		// Ignore trim errors
+	}
+}
+
+async function readJsonl(): Promise<HistoryEntry[]> {
+	try {
+		const raw = await readFile(JSONL_PATH, "utf8");
+		const lines = raw.split("\n").filter((l) => l.trim());
+		return lines.map((l) => JSON.parse(l) as HistoryEntry);
+	} catch {
+		return [];
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Atuin CLI integration
+// ---------------------------------------------------------------------------
+
+async function readAtuinHistory(): Promise<HistoryEntry[]> {
+	try {
+		const { stdout } = await execFileAsync(
+			"atuin",
+			["search", "--format", "{time}\t{command}", "--limit", "200"],
+			{ timeout: ATUIN_TIMEOUT_MS },
+		);
+
+		const lines = stdout.split("\n").filter((l) => l.trim());
+		return lines.map((l) => {
+			const tab = l.indexOf("\t");
+			if (tab === -1) return null;
+			const timeRaw = l.slice(0, tab);
+			const command = l.slice(tab + 1);
+			if (!command.trim()) return null;
+			let timestamp = Date.now();
+			if (timeRaw) {
+				const d = new Date(timeRaw);
+				if (!isNaN(d.getTime())) timestamp = d.getTime();
+			}
+			return {
+				id: `atuin-${timestamp}-${Math.random().toString(36).slice(2, 6)}`,
+				text: command.trim(),
+				timestamp,
+				source: "atuin" as const,
+			};
+		}).filter(Boolean) as HistoryEntry[];
+	} catch {
+		// atuin not installed or failed — fall back to JSONL only
+		return [];
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Unified search API
+// ---------------------------------------------------------------------------
+
+let cachedEntries: HistoryEntry[] | null = null;
+let cacheTime = 0;
+const CACHE_TTL_MS = 5_000;
+
+async function loadAllEntries(): Promise<HistoryEntry[]> {
+	const now = Date.now();
+	if (cachedEntries && now - cacheTime < CACHE_TTL_MS) {
+		return cachedEntries;
+	}
+
+	const [jsonl, atuin] = await Promise.all([readJsonl(), readAtuinHistory()]);
+
+	// Deduplicate: same text within 5s window
+	const seen = new Map<string, HistoryEntry>();
+	const all = [...atuin, ...jsonl];
+
+	for (const entry of all) {
+		const key = entry.text.trim();
+		const existing = seen.get(key);
+		if (!existing || Math.abs(entry.timestamp - existing.timestamp) > 5000) {
+			seen.set(`${key}-${entry.timestamp}`, entry);
+		}
+	}
+
+	const entries = [...seen.values()].sort(
+		(a, b) => b.timestamp - a.timestamp,
+	);
+
+	cachedEntries = entries;
+	cacheTime = now;
+
+	return entries;
+}
+
+export async function searchHistory(
+	query: string,
+	limit = 30,
+): Promise<Array<{ item: HistoryEntry; score: number; indices: number[] }>> {
+	const entries = await loadAllEntries();
+	const results = fuzzySearch(
+		query,
+		entries,
+		(e) => e.text,
+		limit,
+	);
+
+	return results.map((r) => ({
+		item: r.item,
+		score: r.result.score,
+		indices: r.result.indices,
+	}));
+}
+
+export async function listRecent(
+	limit = 30,
+): Promise<HistoryEntry[]> {
+	const entries = await loadAllEntries();
+	return entries.slice(0, limit);
+}
+
+export function invalidateCache(): void {
+	cachedEntries = null;
+	cacheTime = 0;
+}
+
+// ---------------------------------------------------------------------------
+// Write back to atuin (so shell atuin search also sees pi prompts)
+// ---------------------------------------------------------------------------
+
+const ATUIN_AUTHOR = "pi";
+
+export async function writeToAtuin(text: string, cwd: string): Promise<void> {
+	try {
+		const { stdout } = await execFileAsync(
+			"atuin",
+			["history", "start", "--author", ATUIN_AUTHOR, "--", text],
+			{ cwd, timeout: ATUIN_TIMEOUT_MS },
+		);
+		const id = stdout.trim();
+		if (id) {
+			await execFileAsync(
+				"atuin",
+				["history", "end", id, "--exit", "0"],
+				{ cwd, timeout: ATUIN_TIMEOUT_MS },
+			);
+		}
+	} catch {
+		// atuin not installed or failed — silently ignore
+	}
+}

package/index.ts

@@ -0,0 +1,74 @@
+/**
+ * pi-atuin — Atuin-style interactive history search for pi.
+ *
+ * Replaces the default up-arrow behavior with a fuzzy search overlay.
+ * Stores history in ~/.pi/agent/pi-history.jsonl and optionally reads
+ * from atuin's database if installed.
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { CustomEditor } from "@earendil-works/pi-coding-agent";
+import { matchesKey, Key } from "@earendil-works/pi-tui";
+import { addEntry, invalidateCache, listRecent, writeToAtuin } from "./history-store.js";
+import { HistorySearchComponent } from "./search-ui.js";
+
+export default function piAtuin(pi: ExtensionAPI) {
+	// ---- 1. Record user inputs to history ----
+	pi.on("input", async (event, ctx) => {
+		if (event.source === "interactive" && event.text.trim()) {
+			const text = event.text.trim();
+			await addEntry(text, ctx.cwd);
+			// Also write to atuin DB so shell atuin can search pi prompts
+			writeToAtuin(text, ctx.cwd);
+		}
+		return { action: "continue" as const };
+	});
+
+	// ---- 2. Install custom editor with up-arrow search ----
+	pi.on("session_start", async (_event, ctx) => {
+		if (ctx.mode !== "tui") return;
+
+		ctx.ui.setEditorComponent((tui, theme, keybindings) => {
+			const editor = new CustomEditor(tui, theme, keybindings);
+
+			editor.onExtensionShortcut = (data: string) => {
+				if (matchesKey(data, Key.up)) {
+					const cursor = editor.getCursor();
+					if (cursor.line === 0) {
+						openSearch(ctx, editor);
+						return true;
+					}
+				}
+				return false;
+			};
+
+			return editor;
+		});
+	});
+}
+
+async function openSearch(
+	ctx: ExtensionContext,
+	editor: CustomEditor,
+): Promise<void> {
+	const savedText = editor.getText();
+	invalidateCache();
+
+	// Preload entries so the first render already has data
+	const entries = await listRecent(100);
+
+	try {
+		const result = await ctx.ui.custom<string | null>(
+			(_tui, theme, _keybindings, done) =>
+				new HistorySearchComponent(done, theme, entries),
+		);
+
+		if (result !== null && result !== undefined) {
+			editor.setText(result);
+		} else {
+			editor.setText(savedText);
+		}
+	} catch {
+		editor.setText(savedText);
+	}
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "pi-atuin",
+  "version": "0.1.0",
+  "description": "Atuin-style fuzzy history search for pi. Press ↑ for interactive history.",
+  "license": "MIT",
+  "author": "slahser",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/slahser/pi-atuin.git"
+  },
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "atuin",
+    "history",
+    "fuzzy-search"
+  ],
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*"
+  },
+  "files": [
+    "*.ts",
+    "test",
+    "screenshot.png",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/search-ui.ts

@@ -0,0 +1,257 @@
+/**
+ * Atuin-style history search component for pi.
+ *
+ * Layout: newest entries at the bottom, up-arrow goes to older entries.
+ * Data is preloaded before the component renders.
+ */
+
+import type { Component, Focusable } from "@earendil-works/pi-tui";
+import { CURSOR_MARKER, matchesKey, Key, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { searchHistory, listRecent, type HistoryEntry } from "./history-store.js";
+
+interface SearchResult {
+	item: HistoryEntry;
+	score: number;
+	indices: number[];
+}
+
+function fmtTime(ts: number): string {
+	const d = Date.now() - ts;
+	const s = Math.floor(d / 1000);
+	if (s < 60) return `${s}s`;
+	const m = Math.floor(s / 60);
+	if (m < 60) return `${m}m`;
+	const h = Math.floor(m / 60);
+	if (h < 24) return `${h}h`;
+	return `${Math.floor(h / 24)}d`;
+}
+
+function clean(t: string): string {
+	return t.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, " ").trim();
+}
+
+export class HistorySearchComponent implements Component, Focusable {
+	private query = "";
+	private results: SearchResult[];
+	private sel: number;
+	private scroll = 0;
+	private cachedW?: number;
+	private cachedLines?: string[];
+	private _focused = false;
+	private visCount = 15;
+
+	private TS_COL = 5;
+
+	constructor(
+		private done: (r: string | null) => void,
+		private theme: any,
+		entries: HistoryEntry[],
+	) {
+		this.results = [...entries].reverse().map((item) => ({ item, score: 0, indices: [] }));
+		this.sel = Math.max(0, this.results.length - 1);
+		this.scroll = Math.max(0, this.results.length - this.visCount);
+	}
+
+	private async doSearch(): Promise<void> {
+		if (!this.query) {
+			const e = await listRecent(100);
+			this.results = [...e].reverse().map((item) => ({ item, score: 0, indices: [] }));
+		} else {
+			const raw = await searchHistory(this.query, 50);
+			this.results = [...raw].reverse().map((r) => ({
+				item: r.item,
+				score: r.score,
+				indices: r.indices,
+			}));
+		}
+		this.sel = Math.max(0, this.results.length - 1);
+		this.scroll = Math.max(0, this.results.length - this.visCount);
+		this.invalidate();
+	}
+
+	handleInput(data: string): void {
+		if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c"))) {
+			this.done(null);
+			return;
+		}
+		if (matchesKey(data, Key.enter)) {
+			const r = this.results[this.sel];
+			this.done(r ? r.item.text : null);
+			return;
+		}
+		if (matchesKey(data, Key.up)) {
+			if (this.sel > 0) { this.sel--; this.fixScroll(); this.invalidate(); }
+			return;
+		}
+		if (matchesKey(data, Key.down)) {
+			if (this.sel < this.results.length - 1) { this.sel++; this.fixScroll(); this.invalidate(); }
+			return;
+		}
+		if (matchesKey(data, Key.backspace)) {
+			this.query = this.query.slice(0, -1);
+			this.doSearch();
+			return;
+		}
+		if (data.length === 1 && data >= " ") {
+			this.query += data;
+			this.doSearch();
+			return;
+		}
+	}
+
+	private fixScroll(): void {
+		if (this.sel < this.scroll) this.scroll = this.sel;
+		else if (this.sel >= this.scroll + this.visCount) this.scroll = this.sel - this.visCount + 1;
+	}
+
+	/**
+	 * Build a line that is exactly `w` visible characters wide.
+	 * All content goes through this to guarantee no overflow.
+	 */
+	private line(content: string, w: number): string {
+		return truncateToWidth(content, w);
+	}
+
+	private B(ch: string): string {
+		return this.theme.fg("border", ch);
+	}
+
+	private D(s: string): string {
+		return this.theme.fg("dim", s);
+	}
+
+	render(width: number, height?: number): string[] {
+		this.visCount = Math.max(3, (height ?? 20) - 5);
+
+		if (this.cachedW === width && this.cachedLines) return this.cachedLines;
+
+		const W = width;
+		const iw = W - 2; // inner width between border chars
+		const lines: string[] = [];
+
+		const wrap = (inner: string) => {
+			// Total: │(1) + ' '(1) + inner + ' '(1) + │(1) = inner_vw + 4
+			// Want exactly W = iw + 2, so inner_vw must be iw - 2
+			const vw = visibleWidth(inner);
+			const innerW = iw - 2;
+			if (vw > innerW) {
+				inner = truncateToWidth(inner, innerW);
+			}
+			const pad = Math.max(0, innerW - visibleWidth(inner));
+			return this.B("\u2502") + " " + inner + " ".repeat(pad) + " " + this.B("\u2502");
+		};
+
+		// ── Top border ──
+		const title = " Search History ";
+		const tw = title.length;
+		const rb = Math.max(0, iw - tw);
+		const lrb = Math.floor(rb / 2);
+		const rrb = rb - lrb;
+		lines.push(this.line(
+			this.B("\u250C") + this.D("\u2500".repeat(lrb)) + this.theme.fg("accent", title) + this.D("\u2500".repeat(rrb)) + this.B("\u2510"),
+			W,
+		));
+
+		// ── Search input ──
+		const marker = this._focused ? CURSOR_MARKER : "";
+		const q = this.query;
+		const promptW = 2; // "> "
+		const innerW = iw - promptW - 1; // -1 for cursor space
+		const dq = truncateToWidth(q || "", innerW);
+		const cp = dq.length;
+		const inputStr =
+			"> " +
+			dq.slice(0, cp) +
+			marker +
+			`\x1b[7m${dq.slice(cp, cp + 1) || " "}\x1b[27m` +
+			dq.slice(cp + 1);
+		lines.push(wrap(inputStr));
+
+		// ── Separator ──
+		lines.push(this.line(this.B("\u251C") + this.D("\u2500".repeat(iw)) + this.B("\u2524"), W));
+
+		// ── Results ──
+		const vis = this.visCount;
+
+		if (this.results.length === 0) {
+			const msg = this.query ? " No matches " : " No history yet ";
+			lines.push(wrap(this.D(msg)));
+		} else {
+			const maxOff = Math.max(0, this.results.length - vis);
+			this.scroll = Math.min(this.scroll, maxOff);
+			this.scroll = Math.max(0, this.scroll);
+			const end = Math.min(this.results.length, this.scroll + vis);
+
+			for (let i = this.scroll; i < end; i++) {
+				const r = this.results[i];
+				const isSel = i === this.sel;
+				const pfx = isSel ? this.theme.fg("accent", " > ") : "   ";
+
+				const ts = fmtTime(r.item.timestamp);
+				const tsPadded = ts.padStart(this.TS_COL);
+				const tsCol = this.theme.fg("dim", tsPadded);
+				const sep = this.theme.fg("border", " \u2502 ");
+
+				const cmd = clean(r.item.text);
+				const cmdAvail = iw - 3 - this.TS_COL - 3; // pfx + ts + " | "
+				let cmdStr: string;
+				if (r.indices.length > 0 && this.query) {
+					cmdStr = this.hlText(cmd, r.indices, isSel, cmdAvail);
+				} else {
+					cmdStr = this.theme.fg(isSel ? "accent" : "text", truncateToWidth(cmd, cmdAvail));
+				}
+
+				lines.push(wrap(pfx + tsCol + sep + cmdStr));
+			}
+
+			// empty fill
+			for (let i = end - this.scroll; i < vis; i++) {
+				lines.push(wrap(""));
+			}
+		}
+
+		// ── Separator ──
+		lines.push(this.line(this.B("\u251C") + this.D("\u2500".repeat(iw)) + this.B("\u2524"), W));
+
+		// ── Footer ──
+		const total = this.results.length;
+		const pos = total > 0 ? ` ${this.sel + 1}/${total} ` : " 0/0 ";
+		const hints = " type to search  \u2191\u2193 nav  Enter ok  Esc cancel";
+		lines.push(wrap(this.theme.fg("text", pos) + this.D(hints)));
+
+		// ── Bottom border ──
+		lines.push(this.line(this.B("\u2514") + this.D("\u2500".repeat(iw)) + this.B("\u2518"), W));
+
+		this.cachedW = W;
+		this.cachedLines = lines;
+		return lines;
+	}
+
+	private hlText(text: string, indices: number[], sel: boolean, maxW: number): string {
+		const set = new Set(indices);
+		let out = "";
+		for (let i = 0; i < text.length; i++) {
+			if (visibleWidth(out) >= maxW) break;
+			const ch = text[i] === "\t" ? " " : text[i];
+			if (set.has(i)) {
+				out += this.theme.fg("accent", this.theme.bold(ch));
+			} else {
+				out += this.theme.fg(sel ? "accent" : "muted", ch);
+			}
+		}
+		return out;
+	}
+
+	invalidate(): void {
+		this.cachedW = undefined;
+		this.cachedLines = undefined;
+	}
+
+	get focused(): boolean { return this._focused; }
+	set focused(v: boolean) {
+		if (this._focused !== v) {
+			this._focused = v;
+			this.invalidate();
+		}
+	}
+}

package/test/fuzzy-match.test.ts

@@ -0,0 +1,94 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { fuzzyMatch, fuzzySearch } from "../fuzzy-match.js";
+
+describe("fuzzyMatch", () => {
+	it("exact substring match", () => {
+		const r = fuzzyMatch("npm", "npm install");
+		assert.ok(r);
+		assert.ok(r.score > 1000);
+		assert.deepEqual(r.indices, [0, 1, 2]);
+	});
+
+	it("substring at position > 0", () => {
+		const r = fuzzyMatch("install", "npm install");
+		assert.ok(r);
+		assert.ok(r.indices[0] === 4);
+	});
+
+	it("fuzzy character match", () => {
+		const r = fuzzyMatch("ni", "npm install");
+		assert.ok(r);
+		assert.ok(r.indices.length === 2);
+	});
+
+	it("word boundary bonus", () => {
+		const a = fuzzyMatch("in", "npm install");
+		const b = fuzzyMatch("in", "npmxinstall");
+		assert.ok(a);
+		assert.ok(b);
+		assert.ok(a.score > b.score);
+	});
+
+	it("empty query matches everything", () => {
+		const r = fuzzyMatch("", "anything");
+		assert.ok(r);
+		assert.equal(r.score, 1);
+		assert.equal(r.indices.length, 0);
+	});
+
+	it("no match returns null", () => {
+		const r = fuzzyMatch("xyz", "npm install");
+		assert.equal(r, null);
+	});
+
+	it("case insensitive", () => {
+		const r = fuzzyMatch("NPM", "npm install");
+		assert.ok(r);
+		assert.ok(r.score > 0);
+	});
+
+	it("single char query", () => {
+		const r = fuzzyMatch("n", "npm install");
+		assert.ok(r);
+		assert.equal(r.indices.length, 1);
+	});
+});
+
+describe("fuzzySearch", () => {
+	const items = [
+		{ text: "npm install" },
+		{ text: "git commit" },
+		{ text: "npm test" },
+		{ text: "git push" },
+		{ text: "ls -la" },
+	];
+
+	it("returns all items when query is empty", () => {
+		const results = fuzzySearch("", items, (i) => i.text);
+		assert.equal(results.length, items.length);
+	});
+
+	it("filters by query", () => {
+		const results = fuzzySearch("npm", items, (i) => i.text);
+		assert.equal(results.length, 2);
+		assert.ok(results.every((r) => r.item.text.includes("npm")));
+	});
+
+	it("respects limit", () => {
+		const results = fuzzySearch("git", items, (i) => i.text, 1);
+		assert.equal(results.length, 1);
+	});
+
+	it("sorted by score descending", () => {
+		const results = fuzzySearch("npm", items, (i) => i.text);
+		for (let i = 1; i < results.length; i++) {
+			assert.ok(results[i - 1].result.score >= results[i].result.score);
+		}
+	});
+
+	it("returns empty for no matches", () => {
+		const results = fuzzySearch("zzz", items, (i) => i.text);
+		assert.equal(results.length, 0);
+	});
+});

package/test/history-store.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { readFile, writeFile, unlink } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const JSONL_PATH = join(homedir(), ".pi", "agent", "pi-history-test.jsonl");
+
+// Override the path for testing
+const ORIGINAL_PATH = join(homedir(), ".pi", "agent", "pi-history.jsonl");
+
+// We test by directly manipulating the JSONL file since the module
+// uses a hardcoded path. For a more thorough test we'd mock the path,
+// but for now we test the JSONL read/write logic directly.
+
+describe("JSONL read/write", () => {
+	const testPath = join(homedir(), ".pi", "agent", "pi-history-test.jsonl");
+
+	after(async () => {
+		try { await unlink(testPath); } catch {}
+	});
+
+	it("writes and reads JSONL entries", async () => {
+		const entries = [
+			{ id: "1", text: "npm install", timestamp: 1000, source: "pi" },
+			{ id: "2", text: "git commit", timestamp: 2000, source: "pi" },
+		];
+
+		const lines = entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
+		await writeFile(testPath, lines, "utf8");
+
+		const raw = await readFile(testPath, "utf8");
+		const parsed = raw.split("\n").filter((l) => l.trim()).map((l) => JSON.parse(l));
+
+		assert.equal(parsed.length, 2);
+		assert.equal(parsed[0].text, "npm install");
+		assert.equal(parsed[1].text, "git commit");
+	});
+
+	it("handles empty file", async () => {
+		await writeFile(testPath, "", "utf8");
+		const raw = await readFile(testPath, "utf8");
+		const lines = raw.split("\n").filter((l) => l.trim());
+		assert.equal(lines.length, 0);
+	});
+
+	it("trims old entries when exceeding limit", async () => {
+		const entries = Array.from({ length: 100 }, (_, i) => ({
+			id: String(i),
+			text: `command ${i}`,
+			timestamp: i * 1000,
+			source: "pi",
+		}));
+
+		const lines = entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
+		await writeFile(testPath, lines, "utf8");
+
+		// Simulate trim: keep last 50
+		const raw = await readFile(testPath, "utf8");
+		const allLines = raw.split("\n").filter((l) => l.trim());
+		const trimmed = allLines.slice(allLines.length - 50);
+		await writeFile(testPath, trimmed.join("\n") + "\n", "utf8");
+
+		const result = await readFile(testPath, "utf8");
+		const resultLines = result.split("\n").filter((l) => l.trim());
+		assert.equal(resultLines.length, 50);
+
+		const first = JSON.parse(resultLines[0]);
+		assert.equal(first.text, "command 50");
+	});
+});
+
+describe("file permissions", () => {
+	it("JSONL file has restrictive permissions", async () => {
+		try {
+			const stat = await import("node:fs/promises").then((fs) =>
+				fs.stat(ORIGINAL_PATH),
+			);
+			// Check that file is not world-readable (mode & 0o044 === 0)
+			const mode = stat.mode;
+			const worldRead = mode & 0o044; // group + others read
+			assert.equal(worldRead, 0, "File should not be group/others readable");
+		} catch {
+			// File might not exist yet, that's ok
+		}
+	});
+});