@ravshansbox/pi-statusline 1.9.0 → 1.11.0

package/README.md

@@ -1,6 +1,6 @@
 # pi-statusline
 
-Statusline extension for pi.
+Statusline and prompt history extension for pi.
 
 ## Install
 
@@ -18,6 +18,14 @@ Pi loads the extension from `./index.ts`. It replaces the built-in footer with a
 - token usage, cache hit rate and context usage
 - statuses set by other extensions
 
+It also replaces the editor. The editor has no borders and shows `❯ ` before the prompt. It adds shell-style prompt history:
+
+- **Up / Down** recall the previous / next prompt from earlier sessions in the current folder.
+- **Ctrl+R** opens reverse search. Type to filter, Up/Down to move, Tab to switch between current-folder and all-folder history, Enter to load the prompt, Esc to cancel. Text already in the editor becomes the initial query.
+- Empty prompts, slash commands and inline bash (`!`) are skipped. Repeated prompts keep only their newest position. Each search scope holds up to 500 prompts.
+
+Do not use this with `@ravshansbox/pi-prompt-history`; only one extension can replace the editor.
+
 ## Development
 
 ```bash

package/history.ts

@@ -0,0 +1,73 @@
+import { readFile } from 'node:fs/promises';
+import { SessionManager } from '@earendil-works/pi-coding-agent';
+
+export type HistoryScope = 'current' | 'all';
+
+const HISTORY_LIMIT = 500;
+
+type RawEntry = {
+  type?: string;
+  message?: { role?: string; content?: unknown };
+};
+
+function extractText(content: unknown): string {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  return content
+    .filter((block) => block?.type === 'text' && typeof block.text === 'string')
+    .map((block) => block.text as string)
+    .join('\n');
+}
+
+export function isRecallablePrompt(text: string): boolean {
+  const trimmed = text.trim();
+  return trimmed.length > 0 && !trimmed.startsWith('/') && !trimmed.startsWith('!');
+}
+
+async function readPrompts(filePath: string): Promise<string[]> {
+  let raw: string;
+  try {
+    raw = await readFile(filePath, 'utf-8');
+  } catch {
+    return [];
+  }
+  const prompts: string[] = [];
+  for (const line of raw.split('\n')) {
+    if (!line.trim()) continue;
+    let entry: RawEntry;
+    try {
+      entry = JSON.parse(line) as RawEntry;
+    } catch {
+      continue;
+    }
+    if (entry.type !== 'message' || entry.message?.role !== 'user') continue;
+    const text = extractText(entry.message.content);
+    if (isRecallablePrompt(text)) prompts.push(text.trim());
+  }
+  return prompts;
+}
+
+export function uniqueNewest(prompts: string[], limit = Infinity): string[] {
+  const seen = new Set<string>();
+  const newestFirst: string[] = [];
+  for (const prompt of [...prompts].reverse()) {
+    if (seen.has(prompt)) continue;
+    seen.add(prompt);
+    newestFirst.push(prompt);
+    if (newestFirst.length >= limit) break;
+  }
+  return newestFirst.reverse();
+}
+
+export async function loadPromptHistory(cwd: string, scope: HistoryScope): Promise<string[]> {
+  let sessions: Awaited<ReturnType<typeof SessionManager.list>>;
+  try {
+    sessions = scope === 'all' ? await SessionManager.listAll() : await SessionManager.list(cwd);
+  } catch {
+    return [];
+  }
+  const ordered = [...sessions].sort((a, b) => a.modified.getTime() - b.modified.getTime());
+  const all: string[] = [];
+  for (const session of ordered) all.push(...(await readPrompts(session.path)));
+  return uniqueNewest(all, HISTORY_LIMIT);
+}

package/index.ts

@@ -1,6 +1,29 @@
 import { basename } from 'node:path';
-import { type ExtensionAPI, type ExtensionContext } from '@earendil-works/pi-coding-agent';
-import { truncateToWidth } from '@earendil-works/pi-tui';
+import {
+  CustomEditor,
+  getSelectListTheme,
+  type ExtensionAPI,
+  type ExtensionContext,
+  type Theme,
+} from '@earendil-works/pi-coding-agent';
+import {
+  type Component,
+  fuzzyFilter,
+  matchesKey,
+  SelectList,
+  type SelectListTheme,
+  Text,
+  truncateToWidth,
+  type TUI,
+  type TuiMouseEvent,
+  type TuiMouseEventResult,
+} from '@earendil-works/pi-tui';
+import {
+  type HistoryScope,
+  isRecallablePrompt,
+  loadPromptHistory,
+  uniqueNewest,
+} from './history.ts';
 
 type Usage = {
   input: number;
@@ -52,8 +75,207 @@ function getUsage(ctx: ExtensionContext) {
   return { totals, latestCacheHitRate };
 }
 
+const PROMPT = '\u276f ';
+
+class HistoryEditor extends CustomEditor {
+  private prompts: string[] = [];
+  onReverseSearch?: () => void;
+
+  setHistory(prompts: string[]): void {
+    this.prompts = [];
+    for (const prompt of prompts) this.addToHistory(prompt);
+  }
+
+  getHistory(): string[] {
+    return this.prompts;
+  }
+
+  override addToHistory(text: string): void {
+    const trimmed = text.trim();
+    if (isRecallablePrompt(trimmed)) {
+      this.prompts = [...this.prompts.filter((prompt) => prompt !== trimmed), trimmed];
+    }
+    super.addToHistory(text);
+  }
+
+  private contentRows = 0;
+
+  protected override renderTopBorder(): string {
+    return '';
+  }
+
+  protected override renderBottomBorder(): string {
+    return '';
+  }
+
+  override render(width: number): string[] {
+    const lines = super.render(Math.max(1, width - PROMPT.length));
+    const bottom = lines.indexOf('', 1);
+    this.contentRows = bottom - 1;
+    return lines
+      .filter((_, i) => i !== 0 && i !== bottom)
+      .map((line, i) => (i === 0 ? PROMPT : ' '.repeat(PROMPT.length)) + line);
+  }
+
+  override handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined {
+    return super.handleMouse({
+      ...event,
+      x: event.x - PROMPT.length,
+      y: event.y < this.contentRows ? event.y + 1 : event.y + 2,
+      width: event.width - PROMPT.length,
+    });
+  }
+
+  override handleInput(data: string): void {
+    if (matchesKey(data, 'ctrl+r')) {
+      this.onReverseSearch?.();
+      return;
+    }
+    super.handleInput(data);
+  }
+}
+
+class ReverseSearch implements Component {
+  private query: string;
+  private scope: HistoryScope = 'current';
+  private readonly prompts: Record<HistoryScope, string[] | undefined>;
+  private loadingAll = false;
+  private list: SelectList;
+  private readonly header = new Text('', 1, 0);
+  private readonly loadAllPrompts: () => Promise<string[]>;
+  private readonly tui: TUI;
+  private readonly theme: Theme;
+  private readonly listTheme: SelectListTheme;
+  private readonly done: (value: string | null) => void;
+
+  constructor(
+    currentPrompts: string[],
+    initialQuery: string,
+    loadAllPrompts: () => Promise<string[]>,
+    tui: TUI,
+    theme: Theme,
+    listTheme: SelectListTheme,
+    done: (value: string | null) => void,
+  ) {
+    this.loadAllPrompts = loadAllPrompts;
+    this.tui = tui;
+    this.theme = theme;
+    this.listTheme = listTheme;
+    this.done = done;
+    this.query = initialQuery.trim();
+    this.prompts = { current: currentPrompts, all: undefined };
+    this.list = this.buildList();
+    this.refreshHeader();
+  }
+
+  private buildList(): SelectList {
+    const ordered = [...(this.prompts[this.scope] ?? [])].reverse();
+    const prompts = this.query ? fuzzyFilter(ordered, this.query, (p) => p) : ordered;
+    const items = prompts.map((prompt) => ({
+      value: prompt,
+      label: prompt.replace(/\s+/g, ' ').trim(),
+    }));
+    const list = new SelectList(items, 10, this.listTheme);
+    list.onSelect = (item) => this.done(item.value);
+    list.onCancel = () => this.done(null);
+    return list;
+  }
+
+  private refreshHeader(): void {
+    const tabs = (['current', 'all'] as const)
+      .map((scope) => {
+        const label = scope === 'current' ? 'Current folder' : 'All folders';
+        return this.scope === scope
+          ? this.theme.fg('accent', `[${label}]`)
+          : this.theme.fg('dim', label);
+      })
+      .join(this.theme.fg('dim', '  '));
+    const label = this.theme.fg('accent', 'reverse-search');
+    const query = this.query
+      ? this.theme.fg('toolOutput', this.query)
+      : this.theme.fg('dim', '(type to filter)');
+    const loading =
+      this.scope === 'all' && this.loadingAll ? this.theme.fg('dim', ' loading…') : '';
+    const hint = this.theme.fg('dim', '  Tab scope · ↑↓ move · Enter load · Esc cancel');
+    this.header.setText(`${tabs}\n${label}: ${query}${loading}${hint}`);
+  }
+
+  private refresh(): void {
+    this.list = this.buildList();
+    this.refreshHeader();
+    this.tui.requestRender();
+  }
+
+  private switchScope(): void {
+    this.scope = this.scope === 'current' ? 'all' : 'current';
+    if (this.scope === 'all' && !this.prompts.all && !this.loadingAll) {
+      this.loadingAll = true;
+      void this.loadAllPrompts()
+        .catch(() => [])
+        .then((prompts) => {
+          this.prompts.all = prompts;
+          this.loadingAll = false;
+          this.refresh();
+        });
+    }
+    this.refresh();
+  }
+
+  handleInput(data: string): void {
+    if (matchesKey(data, 'escape')) {
+      this.done(null);
+    } else if (matchesKey(data, 'return') || matchesKey(data, 'enter')) {
+      this.done(this.list.getSelectedItem()?.value ?? null);
+    } else if (
+      matchesKey(data, 'tab') ||
+      matchesKey(data, 'right') ||
+      matchesKey(data, 'shift+tab') ||
+      matchesKey(data, 'left')
+    ) {
+      this.switchScope();
+    } else if (matchesKey(data, 'up') || matchesKey(data, 'down')) {
+      this.list.handleInput(data);
+      this.tui.requestRender();
+    } else if (matchesKey(data, 'backspace')) {
+      if (!this.query) return;
+      this.query = this.query.slice(0, -1);
+      this.refresh();
+    } else if (data.length === 1 && data.charCodeAt(0) >= 32) {
+      this.query += data;
+      this.refresh();
+    }
+  }
+
+  render(width: number): string[] {
+    return [...this.header.render(width), ...this.list.render(width)];
+  }
+
+  invalidate(): void {
+    this.header.invalidate();
+    this.list.invalidate();
+  }
+}
+
+async function openReverseSearch(ctx: ExtensionContext, editor: HistoryEditor) {
+  const listTheme = getSelectListTheme();
+  const result = await ctx.ui.custom<string | null>(
+    (tui, theme, _kb, done) =>
+      new ReverseSearch(
+        editor.getHistory(),
+        ctx.ui.getEditorText(),
+        async () =>
+          uniqueNewest([...(await loadPromptHistory(ctx.cwd, 'all')), ...editor.getHistory()]),
+        tui,
+        theme,
+        listTheme,
+        done,
+      ),
+  );
+  if (result) ctx.ui.setEditorText(result);
+}
+
 export default function (pi: ExtensionAPI) {
-  pi.on('session_start', (_event, ctx) => {
+  pi.on('session_start', async (_event, ctx) => {
     if (ctx.mode !== 'tui') return;
     ctx.ui.setFooter((tui, theme, footerData) => {
       const unsub = footerData.onBranchChange(() => tui.requestRender());
@@ -115,5 +337,13 @@ export default function (pi: ExtensionAPI) {
         },
       };
     });
+
+    const prompts = await loadPromptHistory(ctx.cwd, 'current');
+    ctx.ui.setEditorComponent((tui, theme, keybindings) => {
+      const editor = new HistoryEditor(tui, theme, keybindings);
+      editor.setHistory(prompts);
+      editor.onReverseSearch = () => void openReverseSearch(ctx, editor);
+      return editor;
+    });
   });
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ravshansbox/pi-statusline",
-  "version": "1.9.0",
-  "description": "Statusline extension for pi",
+  "version": "1.11.0",
+  "description": "Statusline and prompt history extension for pi",
   "license": "MIT",
   "type": "module",
   "repository": {
@@ -15,7 +15,8 @@
   "keywords": [
     "pi-package",
     "pi-extension",
-    "statusline"
+    "statusline",
+    "prompt-history"
   ],
   "pi": {
     "extensions": [
@@ -42,7 +43,8 @@
     "typescript": "^7.0.2"
   },
   "files": [
-    "index.ts"
+    "index.ts",
+    "history.ts"
   ],
   "publishConfig": {
     "access": "public"