pi-atuin 0.1.7 → 0.1.8

package/history-preview.ts

@@ -0,0 +1,164 @@
+/**
+ * History text normalization and preview helpers for the search TUI.
+ *
+ * normalizeHistoryText — single-line form for list rows and fuzzy search.
+ * buildDetailPreview — multi-line / tail preview for the selected entry.
+ */
+
+export const ELLIPSIS = "…";
+
+export type WidthFn = (text: string) => number;
+
+/** Visible width using Unicode code points (ASCII-safe default for tests). */
+export const codePointWidth: WidthFn = (s) => Array.from(s).length;
+
+function normalizeLineSegment(line: string): string {
+	return line
+		.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, " ")
+		.replace(/\s+/g, " ")
+		.trim();
+}
+
+/** Collapse multiline / control chars into one searchable display line. */
+export function normalizeHistoryText(text: string): string {
+	return text
+		.replace(/\r\n?/g, "\n")
+		.split("\n")
+		.map(normalizeLineSegment)
+		.filter(Boolean)
+		.join(" ");
+}
+
+/** Per-line normalization — keeps line breaks for detail preview. */
+export function normalizeHistoryLines(text: string): string[] {
+	return text.replace(/\r\n?/g, "\n").split("\n").map(normalizeLineSegment);
+}
+
+export function isMultilineHistory(text: string): boolean {
+	return /[\r\n]/.test(text);
+}
+
+/** @deprecated use normalizeHistoryText */
+export const flattenHistoryLine = normalizeHistoryText;
+
+export function truncateToWidthPure(
+	text: string,
+	maxWidth: number,
+	ellipsis: string = ELLIPSIS,
+	widthOf: WidthFn = codePointWidth,
+): string {
+	if (maxWidth <= 0) return "";
+	if (widthOf(text) <= maxWidth) return text;
+
+	const ellW = widthOf(ellipsis);
+	const budget = maxWidth - ellW;
+	if (budget <= 0) return Array.from(ellipsis).slice(0, maxWidth).join("");
+
+	const chars = Array.from(text);
+	let w = 0;
+	let i = 0;
+	while (i < chars.length && w + widthOf(chars[i]!) <= budget) {
+		w += widthOf(chars[i]!);
+		i++;
+	}
+	return chars.slice(0, i).join("") + ellipsis;
+}
+
+export function truncateTailPure(
+	text: string,
+	maxWidth: number,
+	ellipsis: string = ELLIPSIS,
+	widthOf: WidthFn = codePointWidth,
+): string {
+	if (widthOf(text) <= maxWidth) return text;
+
+	const ellW = widthOf(ellipsis);
+	const budget = maxWidth - ellW;
+	if (budget <= 0) return ellipsis;
+
+	const chars = Array.from(text);
+	let w = 0;
+	let start = chars.length;
+	while (start > 0) {
+		const cw = widthOf(chars[start - 1]!);
+		if (w + cw > budget) break;
+		w += cw;
+		start--;
+	}
+	return ellipsis + chars.slice(start).join("");
+}
+
+export function wrapLinePure(
+	line: string,
+	width: number,
+	widthOf: WidthFn = codePointWidth,
+): string[] {
+	if (width <= 0) return line === "" ? [""] : [line];
+	if (line === "") return [""];
+	if (widthOf(line) <= width) return [line];
+
+	const chars = Array.from(line);
+	const result: string[] = [];
+	let i = 0;
+	while (i < chars.length) {
+		let w = 0;
+		let j = i;
+		while (j < chars.length) {
+			const cw = widthOf(chars[j]!);
+			if (w + cw > width) break;
+			w += cw;
+			j++;
+		}
+		if (j === i) j = i + 1;
+		result.push(chars.slice(i, j).join(""));
+		i = j;
+	}
+	return result;
+}
+
+export function needsDetailPreview(
+	rawText: string,
+	listWidth: number,
+	widthOf: WidthFn = codePointWidth,
+): boolean {
+	if (isMultilineHistory(rawText)) return true;
+	return widthOf(normalizeHistoryText(rawText)) > listWidth;
+}
+
+const DETAIL_PREVIEW_MAX_LINES = 2;
+
+/**
+ * Build 1–2 preview lines for the selected history entry.
+ * Multiline: soft-wrap each logical line. Long single line: head + tail.
+ */
+export function buildDetailPreview(
+	rawText: string,
+	width: number,
+	maxLines: number = DETAIL_PREVIEW_MAX_LINES,
+	widthOf: WidthFn = codePointWidth,
+): string[] {
+	if (maxLines <= 0 || width <= 0) return [];
+
+	if (isMultilineHistory(rawText)) {
+		const logical = normalizeHistoryLines(rawText);
+		const out: string[] = [];
+		for (const line of logical) {
+			for (const wrapped of wrapLinePure(line, width, widthOf)) {
+				out.push(wrapped);
+				if (out.length >= maxLines) return out;
+			}
+		}
+		return out;
+	}
+
+	const normalized = normalizeHistoryText(rawText);
+	if (widthOf(normalized) <= width) return [];
+
+	if (maxLines >= 2 && widthOf(normalized) > width * 2) {
+		const head = truncateToWidthPure(normalized, width, ELLIPSIS, widthOf);
+		const tail = truncateTailPure(normalized, width, ELLIPSIS, widthOf);
+		if (head !== tail) return [head, tail];
+	}
+
+	return [truncateTailPure(normalized, width, ELLIPSIS, widthOf)];
+}

package/history-store.ts

@@ -6,6 +6,7 @@ import { readFile, writeFile, appendFile, mkdir } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { fuzzySearch } from "./fuzzy-match.js";
+import { normalizeHistoryText } from "./history-preview.js";
 import { createExecFileAtuinExec, recordAtuinCommand } from "./atuin-cli.js";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
@@ -187,7 +188,7 @@ export async function searchHistory(
 	const results = fuzzySearch(
 		query,
 		entries,
-		(e) => e.text,
+		(e) => normalizeHistoryText(e.text),
 		limit,
 	);
 

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "pi-atuin",
-  "version": "0.1.7",
+  "version": "0.1.8",
+  "type": "module",
   "description": "Atuin-style fuzzy history search for pi. Press ↑ for interactive history.",
   "license": "MIT",
   "author": "RealAlexandreAI",
@@ -24,6 +25,9 @@
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "*"
   },
+  "scripts": {
+    "test": "node --test test/*.test.ts"
+  },
   "files": [
     "*.ts",
     "test",

package/search-ui.ts

@@ -7,6 +7,12 @@
 
 import type { Component, Focusable } from "@earendil-works/pi-tui";
 import { CURSOR_MARKER, matchesKey, Key, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import {
+	buildDetailPreview,
+	needsDetailPreview,
+	normalizeHistoryText,
+	ELLIPSIS as PREVIEW_ELLIPSIS,
+} from "./history-preview.js";
 import { searchHistory, listRecent, type HistoryEntry } from "./history-store.js";
 
 interface SearchResult {
@@ -26,9 +32,8 @@ function fmtTime(ts: number): string {
 	return `${Math.floor(h / 24)}d`;
 }
 
-function clean(t: string): string {
-	return t.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, " ").trim();
-}
+const PREVIEW_MAX_LINES = 2;
+const vw: (s: string) => number = (s) => visibleWidth(s);
 
 export class HistorySearchComponent implements Component, Focusable {
 	private query = "";
@@ -36,6 +41,7 @@ export class HistorySearchComponent implements Component, Focusable {
 	private sel: number;
 	private scroll = 0;
 	private cachedW?: number;
+	private cachedSel?: number;
 	private cachedLines?: string[];
 	private _focused = false;
 	private visCount = 15;
@@ -121,12 +127,24 @@ export class HistorySearchComponent implements Component, Focusable {
 	}
 
 	render(width: number, height?: number): string[] {
-		this.visCount = Math.max(3, (height ?? 20) - 5);
+		const W = width;
+		const iw = W - 2;
 
-		if (this.cachedW === width && this.cachedLines) return this.cachedLines;
+		const cmdAvail = iw - 3 - this.TS_COL - 3;
+		const previewWidth = iw - 2;
+		const selected = this.results[this.sel];
+		const detailPreview =
+			selected && needsDetailPreview(selected.item.text, cmdAvail, vw)
+				? buildDetailPreview(selected.item.text, previewWidth, PREVIEW_MAX_LINES, vw)
+				: [];
+		const previewOverhead = detailPreview.length > 0 ? detailPreview.length + 1 : 0;
+
+		this.visCount = Math.max(3, (height ?? 20) - 5 - previewOverhead);
+
+		if (this.cachedW === width && this.cachedSel === this.sel && this.cachedLines) {
+			return this.cachedLines;
+		}
 
-		const W = width;
-		const iw = W - 2; // inner width between border chars
 		const lines: string[] = [];
 
 		const wrap = (inner: string) => {
@@ -192,13 +210,15 @@ export class HistorySearchComponent implements Component, Focusable {
 				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 + " | "
+				const cmd = normalizeHistoryText(r.item.text);
 				let cmdStr: string;
-				if (r.indices.length > 0 && this.query) {
+				if (this.query && r.indices.length > 0) {
 					cmdStr = this.hlText(cmd, r.indices, isSel, cmdAvail);
 				} else {
-					cmdStr = this.theme.fg(isSel ? "accent" : "text", truncateToWidth(cmd, cmdAvail));
+					cmdStr = this.theme.fg(
+						isSel ? "accent" : "text",
+						truncateToWidth(cmd, cmdAvail, PREVIEW_ELLIPSIS),
+					);
 				}
 
 				lines.push(wrap(pfx + tsCol + sep + cmdStr));
@@ -211,6 +231,13 @@ export class HistorySearchComponent implements Component, Focusable {
 		}
 
 		// ── Separator ──
+		if (detailPreview.length > 0) {
+			lines.push(this.line(this.B("\u251C") + this.D("\u2500".repeat(iw)) + this.B("\u2524"), W));
+			for (const pl of detailPreview) {
+				lines.push(wrap(this.D(pl)));
+			}
+		}
+
 		lines.push(this.line(this.B("\u251C") + this.D("\u2500".repeat(iw)) + this.B("\u2524"), W));
 
 		// ── Footer ──
@@ -223,27 +250,35 @@ export class HistorySearchComponent implements Component, Focusable {
 		lines.push(this.line(this.B("\u2514") + this.D("\u2500".repeat(iw)) + this.B("\u2518"), W));
 
 		this.cachedW = W;
+		this.cachedSel = this.sel;
 		this.cachedLines = lines;
 		return lines;
 	}
 
 	private hlText(text: string, indices: number[], sel: boolean, maxW: number): string {
 		const set = new Set(indices);
-		let out = "";
+		let plain = "";
+		let styled = "";
 		for (let i = 0; i < text.length; i++) {
-			if (visibleWidth(out) >= maxW) break;
-			const ch = text[i] === "\t" ? " " : text[i];
+			const ch = text[i];
+			const nextLen = visibleWidth(plain + ch);
+			if (nextLen > maxW) break;
+			plain += ch;
 			if (set.has(i)) {
-				out += this.theme.fg("accent", this.theme.bold(ch));
+				styled += this.theme.fg("accent", this.theme.bold(ch));
 			} else {
-				out += this.theme.fg(sel ? "accent" : "muted", ch);
+				styled += this.theme.fg(sel ? "accent" : "muted", ch);
 			}
 		}
-		return out;
+		if (plain.length < text.length) {
+			return truncateToWidth(styled, maxW, PREVIEW_ELLIPSIS);
+		}
+		return styled;
 	}
 
 	invalidate(): void {
 		this.cachedW = undefined;
+		this.cachedSel = undefined;
 		this.cachedLines = undefined;
 	}
 

package/test/fuzzy-match.test.ts

@@ -1,6 +1,6 @@
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { fuzzyMatch, fuzzySearch } from "../fuzzy-match.js";
+import { fuzzyMatch, fuzzySearch } from "../fuzzy-match.ts";
 
 describe("fuzzyMatch", () => {
 	it("exact substring match", () => {

package/test/history-preview.test.ts

@@ -0,0 +1,136 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import {
+	buildDetailPreview,
+	flattenHistoryLine,
+	isMultilineHistory,
+	needsDetailPreview,
+	normalizeHistoryText,
+	normalizeHistoryLines,
+	truncateTailPure,
+	truncateToWidthPure,
+	wrapLinePure,
+	ELLIPSIS,
+} from "../history-preview.ts";
+
+describe("normalizeHistoryText", () => {
+	it("collapses newlines to spaces", () => {
+		assert.equal(normalizeHistoryText("npm install\npi /reload"), "npm install pi /reload");
+	});
+
+	it("collapses repeated whitespace", () => {
+		assert.equal(normalizeHistoryText("foo   bar"), "foo bar");
+	});
+
+	it("strips control characters including DEL", () => {
+		assert.equal(normalizeHistoryText("a\u0007b"), "a b");
+		assert.equal(normalizeHistoryText("a\u007fb"), "a b");
+	});
+
+	it("normalizes CRLF", () => {
+		assert.equal(normalizeHistoryText("line1\r\nline2"), "line1 line2");
+	});
+
+	it("flattenHistoryLine alias", () => {
+		assert.equal(flattenHistoryLine("a\nb"), "a b");
+	});
+});
+
+describe("normalizeHistoryLines", () => {
+	it("keeps line breaks", () => {
+		assert.deepEqual(normalizeHistoryLines("npm install\npi /reload"), [
+			"npm install",
+			"pi /reload",
+		]);
+	});
+
+	it("sanitizes each line independently", () => {
+		assert.deepEqual(normalizeHistoryLines("foo\u0007bar\nbaz"), ["foo bar", "baz"]);
+	});
+});
+
+describe("isMultilineHistory", () => {
+	it("detects newline", () => {
+		assert.equal(isMultilineHistory("a\nb"), true);
+		assert.equal(isMultilineHistory("single"), false);
+	});
+});
+
+describe("truncateToWidthPure", () => {
+	it("returns text when it fits", () => {
+		assert.equal(truncateToWidthPure("short", 10), "short");
+	});
+
+	it("truncates with ellipsis at end", () => {
+		assert.equal(truncateToWidthPure("hello world", 8), `hello w${ELLIPSIS}`);
+	});
+});
+
+describe("truncateTailPure", () => {
+	it("keeps the end of long text", () => {
+		const r = truncateTailPure("CREATE USER atuin WITH PASSWORD 'secret'", 20);
+		assert.ok(r.startsWith(ELLIPSIS));
+		assert.ok(r.includes("secret"));
+		assert.ok(!r.includes("CREATE"));
+	});
+});
+
+describe("wrapLinePure", () => {
+	it("splits long lines by width", () => {
+		assert.deepEqual(wrapLinePure("abcdefgh", 3), ["abc", "def", "gh"]);
+	});
+
+	it("returns single chunk when it fits", () => {
+		assert.deepEqual(wrapLinePure("abc", 10), ["abc"]);
+	});
+});
+
+describe("needsDetailPreview", () => {
+	it("true for multiline", () => {
+		assert.equal(needsDetailPreview("a\nb", 80), true);
+	});
+
+	it("true when normalized text exceeds list width", () => {
+		const long = "x".repeat(50);
+		assert.equal(needsDetailPreview(long, 20), true);
+	});
+
+	it("false for short single line", () => {
+		assert.equal(needsDetailPreview("npm install", 40), false);
+	});
+});
+
+describe("buildDetailPreview", () => {
+	it("returns empty for short single line", () => {
+		assert.deepEqual(buildDetailPreview("npm install", 40), []);
+	});
+
+	it("wraps multiline content", () => {
+		const lines = buildDetailPreview("npm install\npi /reload", 12);
+		assert.ok(lines.length >= 2);
+		assert.equal(lines[0], "npm install");
+		assert.equal(lines[1], "pi /reload");
+	});
+
+	it("shows head and tail for very long single line", () => {
+		const long = `git commit -m "${"a".repeat(40)}" --allow-empty`;
+		const lines = buildDetailPreview(long, 20, 2);
+		assert.equal(lines.length, 2);
+		assert.ok(lines[0]!.endsWith(ELLIPSIS));
+		assert.ok(lines[1]!.startsWith(ELLIPSIS));
+	});
+
+	it("shows tail for moderately long single line", () => {
+		const text = "npm run build --project=my-app";
+		const lines = buildDetailPreview(text, 15, 2);
+		assert.equal(lines.length, 1);
+		assert.ok(lines[0]!.startsWith(ELLIPSIS));
+		assert.ok(lines[0]!.includes("my-app"));
+	});
+
+	it("respects maxLines for multiline wrap", () => {
+		const text = "line one is long enough to wrap\nline two\nline three";
+		const lines = buildDetailPreview(text, 10, 2);
+		assert.equal(lines.length, 2);
+	});
+});

package/test/history-search-normalize.test.ts

@@ -0,0 +1,37 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { fuzzySearch } from "../fuzzy-match.ts";
+import { normalizeHistoryText } from "../history-preview.ts";
+
+describe("fuzzy search with normalized history text", () => {
+	const items = [
+		{ text: "npm install\npi /reload" },
+		{ text: "git commit -m fix" },
+		{ text: "npm test" },
+	];
+
+	it("misses cross-line substring on raw text", () => {
+		const results = fuzzySearch("install pi", items, (i) => i.text);
+		assert.equal(results.length, 0);
+	});
+
+	it("matches cross-line substring after normalization", () => {
+		const results = fuzzySearch("install pi", items, (i) => normalizeHistoryText(i.text));
+		assert.equal(results.length, 1);
+		assert.equal(results[0]!.item.text, "npm install\npi /reload");
+	});
+
+	it("indices align with normalized text", () => {
+		const results = fuzzySearch("reload", items, (i) => normalizeHistoryText(i.text));
+		assert.equal(results.length, 1);
+		const normalized = normalizeHistoryText(results[0]!.item.text);
+		const idx = results[0]!.result.indices[0]!;
+		assert.equal(normalized.slice(idx, idx + 6), "reload");
+	});
+
+	it("still matches single-line entries", () => {
+		const results = fuzzySearch("git commit", items, (i) => normalizeHistoryText(i.text));
+		assert.equal(results.length, 1);
+		assert.equal(results[0]!.item.text, "git commit -m fix");
+	});
+});