pi-input-history 1.0.0 → 1.1.0

package/README.md

@@ -1,13 +1,13 @@
 # pi-input-history
 
-**Cross-session prompt history and fuzzy Ctrl+R search for pi.**
+**Cross-session prompt history and fuzzy reverse search for pi.**
 
 [![npm version](https://img.shields.io/npm/v/pi-input-history?style=for-the-badge)](https://www.npmjs.com/package/pi-input-history)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=for-the-badge)](https://opensource.org/licenses/MIT)
 
 ## Why
 
-Pi's built-in ↑/↓ history only covers the current session and is lost on reload. This extension persists your last 100 prompts across sessions and adds fuzzy **Ctrl+R** search to find any past prompt instantly.
+Pi's built-in ↑/↓ history only covers the current session and is lost on reload. This extension persists your last 100 prompts across sessions and adds fuzzy reverse search (default **Ctrl+R**) to find any past prompt instantly.
 
 ![Ctrl+R reverse search](assets/screenshot.png)
 
@@ -29,31 +29,77 @@ pi install git:github.com/ouzhenkun/pi-input-history
 
 On session start, your last 100 prompts across all sessions are loaded into the editor. Use **↑/↓** arrows to browse them as usual.
 
-### Reverse Search (Ctrl+R)
+### Reverse Search
 
-1. Press **Ctrl+R** to open the search overlay.
+1. Press the search shortcut (default **Ctrl+R**) to open the search overlay.
 2. Type to fuzzy-filter history (subsequence matching, space-separated multi-token).
-3. Matched characters are highlighted with your theme's accent color.
-4. Navigate and accept:
+3. Matched characters are highlighted with your theme's accent color, using **minimal-span** matching so the highlight stays on the closest contiguous group (e.g. `in` highlights `in` in `input`, not `pi`'s `i` + `input`'s `n`).
+4. The preview viewport shows the matched record; long lines are **soft-wrapped** (never truncated) and the viewport grows with content up to your terminal's height, then scrolls.
+5. The first matched line is marked with `▸`; the viewport is separated from the input line by a dim divider.
+6. Navigate and accept:
 
 | Key | Action |
 | --- | --- |
-| `Ctrl+R` / `↑` | Cycle to older match |
-| `Ctrl+S` / `↓` | Cycle to newer match |
+| search shortcut / `↑` | Cycle to older match |
+| newer shortcut / `↓` | Cycle to newer match |
+| `ctrl+k` / `ctrl+j` | Scroll the preview viewport (when it exceeds the terminal height) |
 | `Enter` | Accept match into editor |
 | `Esc` / `Ctrl+G` | Cancel |
 
+Defaults: search = `ctrl+r`, newer = `ctrl+s`, scroll up = `ctrl+k`, scroll down = `ctrl+j`.
+
+## Configuration
+
+Optional config at `~/.pi/agent/pi-input-history.json`:
+
+```json
+{
+  "searchShortcut": "ctrl+r",
+  "newerShortcut": "ctrl+s",
+  "scrollUpShortcut": "ctrl+k",
+  "scrollDownShortcut": "ctrl+j"
+}
+```
+
+| Field | Default | Description |
+| --- | --- | --- |
+| `searchShortcut` | `ctrl+r` | Open reverse search; press again in the overlay to cycle older |
+| `newerShortcut` | `ctrl+s` | In the overlay, cycle to a newer match |
+| `scrollUpShortcut` | `ctrl+k` | In the overlay, scroll the preview viewport up |
+| `scrollDownShortcut` | `ctrl+j` | In the overlay, scroll the preview viewport down |
+
+Omit the file or any field to keep the default. After editing, run `/reload` in pi.
+
+### Shortcut conflict with `app.session.rename`
+
+Pi binds `app.session.rename` to `ctrl+r` by default (session picker). This extension can still use `ctrl+r`; pi logs a non-fatal conflict warning and prefers the extension shortcut at the editor level.
+
+To silence the warning while keeping reverse search on Ctrl+R, rebind rename in `~/.pi/agent/keybindings.json`:
+
+```json
+{
+  "app.session.rename": "ctrl+shift+r"
+}
+```
+
+Or change `searchShortcut` in `pi-input-history.json` to another chord.
+
 ## Features
 
 - **Cross-session persistence** — history survives across sessions automatically.
 - **Fuzzy subsequence matching** — type partial characters in order, multi-token support with spaces.
-- **Character-level highlighting** — matched positions shown with accent color underline.
+- **Minimal-span highlighting** — matched characters form the closest contiguous group, so `in` highlights `input`, not scattered chars.
+- **Soft-wrapped preview** — long lines wrap to multiple lines instead of being truncated with `...`.
+- **Adaptive viewport height** — the preview grows with content up to the terminal height, then scrolls.
+- **Scrollable viewport** — `ctrl+k` / `ctrl+j` to browse the whole record.
+- **Match markers** — the first matched line is marked with `▸`, separated by a dim divider.
 - **Deduplication** — no duplicate entries across sessions.
 - **Current session awareness** — merges live branch history with cached cross-session history.
+- **Configurable shortcuts** — override via `pi-input-history.json`.
 
 ## Acknowledgments
 
-The Ctrl+R reverse search component is inspired by [pi-readline-search](https://github.com/mrshu/pi-readline-search) by [@mrshu](https://github.com/mrshu).
+The reverse search component is inspired by [pi-readline-search](https://github.com/mrshu/pi-readline-search) by [@mrshu](https://github.com/mrshu).
 
 ## License
 

package/index.ts

@@ -1,19 +1,25 @@
 /**
- * Persistent History + Ctrl+R Reverse Search
+ * Persistent History + Reverse Search
  *
  * - Loads recent prompts from previous sessions into up/down history on startup.
- * - Ctrl+R opens a reverse search overlay (fuzzy subsequence matching).
+ * - Configurable reverse search overlay (fuzzy subsequence matching).
  *
- * Hotkeys while searching:
- * - Ctrl+R / ↑ : older match
- * - Ctrl+S / ↓ : newer match
- * - Enter      : accept match (fills editor)
- * - Esc/Ctrl+G : cancel
+ * Config: ~/.pi/agent/pi-input-history.json
+ *   { "searchShortcut": "ctrl+r", "newerShortcut": "ctrl+s" }
+ *
+ * Hotkeys while searching (defaults):
+ * - searchShortcut / ↑ : older match
+ * - newerShortcut / ↓  : newer match
+ * - Enter              : accept match (fills editor)
+ * - Esc/Ctrl+G         : cancel
  */
 
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
 import {
   CustomEditor,
   SessionManager,
+  getAgentDir,
   type ExtensionAPI,
 } from "@earendil-works/pi-coding-agent";
 import type { UserMessage } from "@earendil-works/pi-ai";
@@ -22,16 +28,66 @@ import {
   Key,
   matchesKey,
   truncateToWidth,
+  visibleWidth,
   type Component,
   type Focusable,
+  type KeyId,
   type TUI,
 } from "@earendil-works/pi-tui";
 
 const MAX_MESSAGES = 100;
+const DEFAULT_SEARCH_SHORTCUT: KeyId = "ctrl+r";
+const DEFAULT_NEWER_SHORTCUT: KeyId = "ctrl+s";
+const DEFAULT_SCROLL_UP_SHORTCUT: KeyId = "ctrl+k";
+const DEFAULT_SCROLL_DOWN_SHORTCUT: KeyId = "ctrl+j";
+/** Visible preview lines in the reverse-search viewport. */
+const PREVIEW_LINES = 3;
+
+type Config = {
+  searchShortcut: KeyId;
+  newerShortcut: KeyId;
+  scrollUpShortcut: KeyId;
+  scrollDownShortcut: KeyId;
+};
+
+function normalizeKey(value: unknown, fallback: KeyId): KeyId {
+  if (typeof value !== "string") return fallback;
+  const s = value.trim().toLowerCase();
+  return s.length > 0 ? (s as KeyId) : fallback;
+}
+
+function loadConfig(): Config {
+  try {
+    const path = join(getAgentDir(), "pi-input-history.json");
+    if (!existsSync(path)) {
+      return {
+        searchShortcut: DEFAULT_SEARCH_SHORTCUT,
+        newerShortcut: DEFAULT_NEWER_SHORTCUT,
+        scrollUpShortcut: DEFAULT_SCROLL_UP_SHORTCUT,
+        scrollDownShortcut: DEFAULT_SCROLL_DOWN_SHORTCUT,
+      };
+    }
+    const raw = JSON.parse(readFileSync(path, "utf-8")) as Record<string, unknown>;
+    return {
+      searchShortcut: normalizeKey(raw.searchShortcut, DEFAULT_SEARCH_SHORTCUT),
+      newerShortcut: normalizeKey(raw.newerShortcut, DEFAULT_NEWER_SHORTCUT),
+      scrollUpShortcut: normalizeKey(raw.scrollUpShortcut, DEFAULT_SCROLL_UP_SHORTCUT),
+      scrollDownShortcut: normalizeKey(raw.scrollDownShortcut, DEFAULT_SCROLL_DOWN_SHORTCUT),
+    };
+  } catch {
+    return {
+      searchShortcut: DEFAULT_SEARCH_SHORTCUT,
+      newerShortcut: DEFAULT_NEWER_SHORTCUT,
+      scrollUpShortcut: DEFAULT_SCROLL_UP_SHORTCUT,
+      scrollDownShortcut: DEFAULT_SCROLL_DOWN_SHORTCUT,
+    };
+  }
+}
 
 // ─── Extension Entry ───────────────────────────────────────────────────────────
 
 export default function (pi: ExtensionAPI) {
+  const config = loadConfig();
   let historyCache: string[] = [];
 
   pi.on("session_start", async (_event, ctx) => {
@@ -53,11 +109,9 @@ export default function (pi: ExtensionAPI) {
     });
   });
 
-  // Ctrl+R: reverse search
-  pi.registerShortcut("ctrl+r", {
+  pi.registerShortcut(config.searchShortcut, {
     description: "Reverse search through prompt history",
     handler: async (ctx) => {
-      // Merge cached history with current session's branch history
       const branchHistory = collectBranchHistory(ctx);
       const merged = mergeHistory(branchHistory, historyCache);
 
@@ -67,7 +121,7 @@ export default function (pi: ExtensionAPI) {
       }
 
       const selected = await ctx.ui.custom<string | null>((tui, theme, _kb, done) => {
-        return new ReverseSearchComponent(tui, theme, merged, done);
+        return new ReverseSearchComponent(tui, theme, merged, done, config);
       }, { overlay: true, overlayOptions: { anchor: "bottom-center", width: "100%" } });
 
       if (selected === null) return;
@@ -98,57 +152,205 @@ function fuzzyMatch(item: string, query: string): boolean {
   return tokens.every((t) => subsequence(lower, t));
 }
 
-function toSingleLinePreview(text: string): string {
-  return text.replace(/\s+/g, " ").trim();
+/** Find the indices matching `token` as a subsequence with the smallest spread. */
+function bestSubsequenceSpan(text: string, token: string): number[] {
+  const positions: number[][] = [];
+  for (const ch of token) {
+    const idxs: number[] = [];
+    for (let i = 0; i < text.length; i++) if (text[i] === ch) idxs.push(i);
+    positions.push(idxs);
+  }
+  if (positions.some((arr) => arr.length === 0)) return [];
+
+  const lowerBound = (arr: number[], min: number): number => {
+    let lo = 0;
+    let hi = arr.length;
+    while (lo < hi) {
+      const mid = (lo + hi) >> 1;
+      if (arr[mid]! < min) lo = mid + 1;
+      else hi = mid;
+    }
+    return lo;
+  };
+
+  let bestSpan = Infinity;
+  let bestIdx: number[] = [];
+  for (const c0 of positions[0]!) {
+    const cur = [c0];
+    let prev = c0;
+    let ok = true;
+    for (let t = 1; t < token.length; t++) {
+      const arr = positions[t]!;
+      const p = lowerBound(arr, prev + 1);
+      if (p >= arr.length) {
+        ok = false;
+        break;
+      }
+      const nxt = arr[p]!;
+      cur.push(nxt);
+      prev = nxt;
+    }
+    if (!ok) continue;
+    const span = cur[cur.length - 1]! - c0;
+    if (span < bestSpan) {
+      bestSpan = span;
+      bestIdx = cur;
+    }
+  }
+  return bestIdx;
 }
 
-/** Highlight matched characters (subsequence) with underline + accent color. */
-function highlightMatch(text: string, query: string, theme: any, maxWidth: number): string {
-  // Truncate plain text first to ensure it fits
-  const truncated = truncateToWidth(text, maxWidth);
-  // Strip any ANSI that truncateToWidth might have added for ellipsis
-  const plain = truncated.replace(/\x1b\[[0-9;]*m/g, "");
-
-  if (!query) return theme.fg("text", plain);
-
-  // Find positions of subsequence-matched characters
-  const lower = plain.toLowerCase();
+/** Collect character indices (in `text`) matched by each query token (smallest-spread subsequence). */
+function collectMatchPositions(text: string, query: string): Set<number> {
+  const positions = new Set<number>();
+  if (!query) return positions;
+  const lower = text.toLowerCase();
   const tokens = query.toLowerCase().split(/\s+/).filter(Boolean);
-  const matchPositions = new Set<number>();
-
   for (const token of tokens) {
-    let hi = 0;
-    for (let ni = 0; ni < token.length; ni++) {
-      const idx = lower.indexOf(token[ni], hi);
-      if (idx !== -1) {
-        matchPositions.add(idx);
-        hi = idx + 1;
-      }
-    }
+    const best = bestSubsequenceSpan(lower, token);
+    for (const idx of best) positions.add(idx);
   }
+  return positions;
+}
 
-  // Build styled string — group consecutive chars to reduce ANSI overhead
+/** Underline + accent-highlight matched characters; plain text for the rest. */
+function highlightSegments(text: string, positions: Set<number>, theme: any): string {
   let result = "";
   let i = 0;
-  while (i < plain.length) {
-    if (matchPositions.has(i)) {
-      // Collect consecutive matched chars
+  while (i < text.length) {
+    if (positions.has(i)) {
       let j = i;
-      while (j < plain.length && matchPositions.has(j)) j++;
-      // Accent color + underline
-      result += `\x1b[4m${theme.fg("accent", plain.slice(i, j))}\x1b[24m`;
+      while (j < text.length && positions.has(j)) j++;
+      result += `\x1b[4m${theme.fg("accent", text.slice(i, j))}\x1b[24m`;
       i = j;
     } else {
-      // Collect consecutive non-matched chars
       let j = i;
-      while (j < plain.length && !matchPositions.has(j)) j++;
-      result += theme.fg("text", plain.slice(i, j));
+      while (j < text.length && !positions.has(j)) j++;
+      result += theme.fg("text", text.slice(i, j));
       i = j;
     }
   }
   return result;
 }
 
+const GRAPHEME_SEGMENTER =
+  typeof Intl !== "undefined" && typeof (Intl as any).Segmenter === "function"
+    ? new (Intl as any).Segmenter(undefined, { granularity: "grapheme" })
+    : null;
+
+type WrappedLine = { text: string; start: number; end: number };
+
+/** Soft-wrap `text` to `maxWidth` columns; `\n` forces a hard break; content is never truncated. */
+function wrapText(text: string, maxWidth: number): WrappedLine[] {
+  if (maxWidth <= 0) return [{ text: "", start: 0, end: 0 }];
+  const lines: WrappedLine[] = [];
+  let cur = "";
+  let curW = 0;
+  let curStart = 0;
+  const push = (wLine: WrappedLine) => lines.push(wLine);
+  if (GRAPHEME_SEGMENTER) {
+    for (const { segment, index } of GRAPHEME_SEGMENTER.segment(text)) {
+      if (segment === "\n") {
+        push({ text: cur, start: curStart, end: index });
+        cur = "";
+        curW = 0;
+        curStart = index + 1;
+        continue;
+      }
+      const w = visibleWidth(segment);
+      if (curW + w > maxWidth && curW > 0) {
+        push({ text: cur, start: curStart, end: index });
+        cur = segment;
+        curW = w;
+        curStart = index;
+      } else {
+        cur += segment;
+        curW += w;
+      }
+    }
+  } else {
+    for (let idx = 0; idx < text.length; ) {
+      const cp = text.codePointAt(idx)!;
+      const ch = String.fromCodePoint(cp);
+      if (ch === "\n") {
+        push({ text: cur, start: curStart, end: idx });
+        cur = "";
+        curW = 0;
+        curStart = idx + 1;
+        idx += 1;
+        continue;
+      }
+      const w = visibleWidth(ch);
+      if (curW + w > maxWidth && curW > 0) {
+        push({ text: cur, start: curStart, end: idx });
+        cur = ch;
+        curW = w;
+        curStart = idx;
+      } else {
+        cur += ch;
+        curW += w;
+      }
+      idx += ch.length;
+    }
+  }
+  if (curW > 0 || text.length === 0) {
+    push({ text: cur, start: curStart, end: text.length });
+  } else if (text.endsWith("\n") && lines.length > 0) {
+    push({ text: "", start: text.length, end: text.length });
+  }
+  return lines;
+}
+
+/** Highlight the matched positions within one wrapped line. */
+function renderWrappedLine(line: WrappedLine, matchPositions: Set<number>, theme: any): string {
+  const local = new Set<number>();
+  for (const p of matchPositions) {
+    if (p >= line.start && p < line.end) local.add(p - line.start);
+  }
+  return local.size === 0 ? theme.fg("text", line.text) : highlightSegments(line.text, local, theme);
+}
+
+/** Render the viewport over wrapped lines; mark the first matched line with `▸`. */
+function renderWrappedLines(
+  lines: WrappedLine[],
+  scroll: number,
+  viewportLines: number,
+  markIndex: number,
+  matchPositions: Set<number>,
+  theme: any,
+): string[] {
+  const out: string[] = [];
+  for (let k = 0; k < viewportLines; k++) {
+    const ln = lines[scroll + k];
+    const text = ln ? renderWrappedLine(ln, matchPositions, theme) : "";
+    const arrow = ln && scroll + k === markIndex ? "▸ " : "";
+    out.push(arrow + text);
+  }
+  return out;
+}
+
+/** Wrap a (CRLF-normalized) record, locate the first matched line, and collect match positions. */
+function buildWrappedMatch(
+  record: string,
+  query: string,
+  maxWidth: number,
+): { lines: WrappedLine[]; anchor: number; positions: Set<number> } {
+  const normalized = record.replace(/\r\n/g, "\n");
+  const lines = wrapText(normalized, maxWidth);
+  const positions = collectMatchPositions(normalized, query);
+  let anchor = 0;
+  if (positions.size > 0) {
+    const first = Math.min(...positions);
+    for (let i = 0; i < lines.length; i++) {
+      if (first >= lines[i]!.start && first < lines[i]!.end) {
+        anchor = i;
+        break;
+      }
+    }
+  }
+  return { lines, anchor, positions };
+}
+
 class ReverseSearchComponent implements Component, Focusable {
   private _focused = false;
   private readonly input = new Input();
@@ -156,12 +358,15 @@ class ReverseSearchComponent implements Component, Focusable {
   private query = "";
   private matchIndices: number[] = [];
   private matchPointer = 0;
+  private previewScroll = 0;
+  private previewAutoLocate = true;
 
   constructor(
     private readonly tui: TUI,
     private readonly theme: any,
     private readonly history: string[],
     private readonly done: Done,
+    private readonly config: Config,
   ) {
     this.input.onEscape = () => this.done(null);
     this.input.onSubmit = () => {
@@ -192,6 +397,7 @@ class ReverseSearchComponent implements Component, Focusable {
     if (this.matchPointer >= this.matchIndices.length) {
       this.matchPointer = Math.max(0, this.matchIndices.length - 1);
     }
+    this.previewAutoLocate = true;
   }
 
   private getCurrentMatch(): string | undefined {
@@ -203,21 +409,23 @@ class ReverseSearchComponent implements Component, Focusable {
   private cycleOlder(): void {
     if (this.matchIndices.length === 0) return;
     this.matchPointer = (this.matchPointer + 1) % this.matchIndices.length;
+    this.previewAutoLocate = true;
   }
 
   private cycleNewer(): void {
     if (this.matchIndices.length === 0) return;
     this.matchPointer = (this.matchPointer - 1 + this.matchIndices.length) % this.matchIndices.length;
+    this.previewAutoLocate = true;
   }
 
   handleInput(data: string): void {
-    if (matchesKey(data, Key.ctrl("r")) || matchesKey(data, Key.up)) {
+    if (matchesKey(data, this.config.searchShortcut) || matchesKey(data, Key.up)) {
       this.cycleOlder();
       this.tui.requestRender();
       return;
     }
 
-    if (matchesKey(data, Key.ctrl("s")) || matchesKey(data, Key.down)) {
+    if (matchesKey(data, this.config.newerShortcut) || matchesKey(data, Key.down)) {
       this.cycleNewer();
       this.tui.requestRender();
       return;
@@ -228,6 +436,20 @@ class ReverseSearchComponent implements Component, Focusable {
       return;
     }
 
+    if (matchesKey(data, this.config.scrollUpShortcut)) {
+      this.previewAutoLocate = false;
+      this.previewScroll = Math.max(0, this.previewScroll - 1);
+      this.tui.requestRender();
+      return;
+    }
+
+    if (matchesKey(data, this.config.scrollDownShortcut)) {
+      this.previewAutoLocate = false;
+      this.previewScroll += 1;
+      this.tui.requestRender();
+      return;
+    }
+
     const before = this.input.getValue();
     this.input.handleInput(data);
     const after = this.input.getValue();
@@ -244,30 +466,47 @@ class ReverseSearchComponent implements Component, Focusable {
     const t = this.theme;
     const currentMatch = this.getCurrentMatch();
 
-    // Reserve space for prefix and counter (use fixed max counter width)
     const prefix = "(reverse-search) ";
-    const maxCounterWidth = 10; // " [xx/xx]" is enough
+    const maxCounterWidth = 10;
     const availableWidth = Math.max(10, width - prefix.length - maxCounterWidth);
 
     const counterText = this.matchIndices.length > 0
       ? ` [${this.matchPointer + 1}/${this.matchIndices.length}]`
       : " [0/0]";
 
-    const matchPreview = currentMatch
-      ? highlightMatch(toSingleLinePreview(currentMatch), this.query, t, availableWidth)
-      : t.fg("warning", "no match");
-
     const counter = t.fg("dim", counterText);
 
-    const header =
-      t.fg("accent", prefix) +
-      matchPreview +
-      counter;
+    const lines: string[] = [];
+    if (currentMatch) {
+      lines.push(t.fg("accent", prefix) + counter);
+      const sep = t.fg("dim", "─".repeat(Math.max(1, width)));
+      lines.push(sep);
+      const { lines: wl, anchor, positions } = buildWrappedMatch(currentMatch, this.query, availableWidth);
+      const terminalRows = this.tui.terminal.rows;
+      const maxVp = Math.max(PREVIEW_LINES, terminalRows - 6);
+      const viewportLines = Math.max(PREVIEW_LINES, Math.min(wl.length, maxVp));
+      const maxScroll = Math.max(0, wl.length - viewportLines);
+      const scroll = this.previewAutoLocate
+        ? Math.min(maxScroll, Math.max(0, anchor - Math.floor(viewportLines / 2)))
+        : Math.min(maxScroll, Math.max(0, this.previewScroll));
+      this.previewScroll = scroll;
+      lines.push(...renderWrappedLines(wl, scroll, viewportLines, anchor, positions, t));
+      lines.push(sep);
+    } else {
+      lines.push(t.fg("accent", prefix) + t.fg("warning", "no match") + counter);
+    }
 
     const inputLine = truncateToWidth(this.input.render(width)[0] ?? "", width);
-    const help = truncateToWidth(t.fg("dim", "ctrl+r/↑ older • ctrl+s/↓ newer • enter accept • esc cancel"), width);
+    const help = truncateToWidth(
+      t.fg(
+        "dim",
+        `${this.config.searchShortcut}/↑ older • ${this.config.newerShortcut}/↓ newer • ${this.config.scrollUpShortcut}/${this.config.scrollDownShortcut} scroll • enter accept • esc cancel`,
+      ),
+      width,
+    );
 
-    return [truncateToWidth(header, width), inputLine, help];
+    lines.push(inputLine, help);
+    return lines.map((l) => truncateToWidth(l, width));
   }
 
   invalidate(): void {
@@ -350,7 +589,6 @@ function extractUserMessages(sessionPath: string): string[] {
       const text = extractText(entry.message.content);
       if (text) messages.push(text);
     }
-    // Reverse so newest messages come first within each session
     return messages.reverse();
   } catch {
     return [];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-input-history",
-  "version": "1.0.0",
-  "description": "Cross-session prompt history and fuzzy Ctrl+R search for pi.",
+  "version": "1.1.0",
+  "description": "Cross-session prompt history and fuzzy reverse search for pi.",
   "keywords": [
     "pi",
     "pi-package",