@oh-my-pi/pi-coding-agent 4.0.1 → 4.1.0

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## [Unreleased]
 
+## [4.1.0] - 2026-01-10
+### Added
+
+- Added persistent prompt history with SQLite-backed storage and Ctrl+R search
+
+### Fixed
+
+- Fixed credential blocking logic to correctly check for remaining available credentials instead of always returning true
+
 ## [4.0.1] - 2026-01-10
 ### Added
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "4.0.1",
+	"version": "4.1.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -39,10 +39,10 @@
 		"prepublishOnly": "bun run generate-template && bun run clean && bun run build"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-ai": "4.0.1",
-		"@oh-my-pi/pi-agent-core": "4.0.1",
-		"@oh-my-pi/pi-git-tool": "4.0.1",
-		"@oh-my-pi/pi-tui": "4.0.1",
+		"@oh-my-pi/pi-ai": "4.1.0",
+		"@oh-my-pi/pi-agent-core": "4.1.0",
+		"@oh-my-pi/pi-git-tool": "4.1.0",
+		"@oh-my-pi/pi-tui": "4.1.0",
 		"@openai/agents": "^0.3.7",
 		"@sinclair/typebox": "^0.34.46",
 		"ajv": "^8.17.1",

package/src/core/auth-storage.ts

@@ -797,7 +797,15 @@ export class AuthStorage {
 		}
 
 		this.markCredentialBlocked(providerKey, sessionCredential.index, blockedUntil);
-		return true;
+
+		const remainingCredentials = this.getCredentialsForProvider(provider)
+			.map((credential, index) => ({ credential, index }))
+			.filter(
+				(entry): entry is { credential: AuthCredential; index: number } =>
+					entry.credential.type === sessionCredential.type && entry.index !== sessionCredential.index,
+			);
+
+		return remainingCredentials.some((candidate) => !this.isCredentialBlocked(providerKey, candidate.index));
 	}
 
 	/**

package/src/core/history-storage.ts

@@ -0,0 +1,166 @@
+import { Database } from "bun:sqlite";
+import { dirname, join } from "node:path";
+import { getAgentDir } from "../config";
+import { logger } from "./logger";
+
+export interface HistoryEntry {
+	id: number;
+	prompt: string;
+	created_at: number;
+	cwd?: string;
+}
+
+type Statement = ReturnType<Database["prepare"]>;
+
+type HistoryRow = {
+	id: number;
+	prompt: string;
+	created_at: number;
+	cwd: string | null;
+};
+
+export class HistoryStorage {
+	private db: Database;
+	private static instance?: HistoryStorage;
+
+	// Prepared statements
+	private insertStmt: Statement;
+	private recentStmt: Statement;
+	private searchStmt: Statement;
+	private lastPromptStmt: Statement;
+
+	private constructor(dbPath: string) {
+		this.ensureDir(dbPath);
+
+		this.db = new Database(dbPath);
+
+		const hasFts = this.db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='history_fts'").get();
+
+		this.db.exec(`
+PRAGMA journal_mode=WAL;
+PRAGMA synchronous=NORMAL;
+
+CREATE TABLE IF NOT EXISTS history (
+	id INTEGER PRIMARY KEY AUTOINCREMENT,
+	prompt TEXT NOT NULL,
+	created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+	cwd TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_history_created_at ON history(created_at DESC);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS history_fts USING fts5(prompt, content='history', content_rowid='id');
+
+CREATE TRIGGER IF NOT EXISTS history_ai AFTER INSERT ON history BEGIN
+	INSERT INTO history_fts(rowid, prompt) VALUES (new.id, new.prompt);
+END;
+`);
+
+		if (!hasFts) {
+			try {
+				this.db.run("INSERT INTO history_fts(history_fts) VALUES('rebuild')");
+			} catch (error) {
+				logger.warn("HistoryStorage FTS rebuild failed", { error: String(error) });
+			}
+		}
+
+		this.insertStmt = this.db.prepare("INSERT INTO history (prompt, cwd) VALUES (?, ?)");
+		this.recentStmt = this.db.prepare(
+			"SELECT id, prompt, created_at, cwd FROM history ORDER BY created_at DESC, id DESC LIMIT ?",
+		);
+		this.searchStmt = this.db.prepare(
+			"SELECT h.id, h.prompt, h.created_at, h.cwd FROM history_fts f JOIN history h ON h.id = f.rowid WHERE history_fts MATCH ? ORDER BY h.created_at DESC, h.id DESC LIMIT ?",
+		);
+		this.lastPromptStmt = this.db.prepare("SELECT prompt FROM history ORDER BY id DESC LIMIT 1");
+	}
+
+	static open(dbPath: string = join(getAgentDir(), "history.db")): HistoryStorage {
+		if (!HistoryStorage.instance) {
+			HistoryStorage.instance = new HistoryStorage(dbPath);
+		}
+		return HistoryStorage.instance;
+	}
+
+	add(prompt: string, cwd?: string): void {
+		const trimmed = prompt.trim();
+		if (!trimmed) return;
+
+		try {
+			const last = this.lastPromptStmt.get() as { prompt?: string } | undefined;
+			if (last?.prompt === trimmed) return;
+
+			this.insertStmt.run(trimmed, cwd ?? null);
+		} catch (error) {
+			logger.error("HistoryStorage add failed", { error: String(error) });
+		}
+	}
+
+	getRecent(limit: number): HistoryEntry[] {
+		const safeLimit = this.normalizeLimit(limit);
+		if (safeLimit === 0) return [];
+
+		try {
+			const rows = this.recentStmt.all(safeLimit) as HistoryRow[];
+			return rows.map((row) => this.toEntry(row));
+		} catch (error) {
+			logger.error("HistoryStorage getRecent failed", { error: String(error) });
+			return [];
+		}
+	}
+
+	search(query: string, limit: number): HistoryEntry[] {
+		const safeLimit = this.normalizeLimit(limit);
+		if (safeLimit === 0) return [];
+
+		const ftsQuery = this.buildFtsQuery(query);
+		if (!ftsQuery) return [];
+
+		try {
+			const rows = this.searchStmt.all(ftsQuery, safeLimit) as HistoryRow[];
+			return rows.map((row) => this.toEntry(row));
+		} catch (error) {
+			logger.error("HistoryStorage search failed", { error: String(error) });
+			return [];
+		}
+	}
+
+	private ensureDir(dbPath: string): void {
+		const dir = dirname(dbPath);
+		const result = Bun.spawnSync(["mkdir", "-p", dir]);
+		if (result.exitCode !== 0) {
+			const stderr = result.stderr ? new TextDecoder().decode(result.stderr) : "";
+			throw new Error(`Failed to create history directory: ${dir} ${stderr}`.trim());
+		}
+	}
+
+	private normalizeLimit(limit: number): number {
+		if (!Number.isFinite(limit)) return 0;
+		const clamped = Math.max(0, Math.floor(limit));
+		return Math.min(clamped, 1000);
+	}
+
+	private buildFtsQuery(query: string): string | null {
+		const tokens = query
+			.trim()
+			.split(/\s+/)
+			.map((token) => token.trim())
+			.filter(Boolean);
+
+		if (tokens.length === 0) return null;
+
+		return tokens
+			.map((token) => {
+				const escaped = token.replace(/"/g, '""');
+				return `"${escaped}"*`;
+			})
+			.join(" ");
+	}
+
+	private toEntry(row: HistoryRow): HistoryEntry {
+		return {
+			id: row.id,
+			prompt: row.prompt,
+			created_at: row.created_at,
+			cwd: row.cwd ?? undefined,
+		};
+	}
+}

package/src/core/index.ts

@@ -25,6 +25,7 @@ export {
 	loadExtensionFromFactory,
 	type ToolDefinition,
 } from "./extensions/index";
+export { HistoryStorage } from "./history-storage";
 export {
 	createMCPManager,
 	discoverAndLoadMCPTools,

package/src/core/keybindings.ts

@@ -26,6 +26,7 @@ export type AppAction =
 	| "expandTools"
 	| "toggleThinking"
 	| "externalEditor"
+	| "historySearch"
 	| "followUp"
 	| "dequeue";
 
@@ -53,6 +54,7 @@ export const DEFAULT_APP_KEYBINDINGS: Record<AppAction, KeyId | KeyId[]> = {
 	cycleModelForward: "ctrl+p",
 	cycleModelBackward: "shift+ctrl+p",
 	selectModel: "ctrl+l",
+	historySearch: "ctrl+r",
 	expandTools: "ctrl+o",
 	toggleThinking: "ctrl+t",
 	externalEditor: "ctrl+g",
@@ -78,6 +80,7 @@ const APP_ACTIONS: AppAction[] = [
 	"cycleModelForward",
 	"cycleModelBackward",
 	"selectModel",
+	"historySearch",
 	"expandTools",
 	"toggleThinking",
 	"externalEditor",

package/src/modes/interactive/components/custom-editor.ts

@@ -29,6 +29,7 @@ export class CustomEditor extends Editor {
 	public onCtrlP?: () => void;
 	public onShiftCtrlP?: () => void;
 	public onCtrlL?: () => void;
+	public onCtrlR?: () => void;
 	public onCtrlO?: () => void;
 	public onCtrlT?: () => void;
 	public onCtrlG?: () => void;
@@ -113,6 +114,12 @@ export class CustomEditor extends Editor {
 			return;
 		}
 
+		// Intercept Ctrl+R for history search
+		if (matchesKey(data, "ctrl+r") && this.onCtrlR) {
+			this.onCtrlR();
+			return;
+		}
+
 		// Intercept Ctrl+O for tool output expansion
 		if (isCtrlO(data) && this.onCtrlO) {
 			this.onCtrlO();

package/src/modes/interactive/components/history-search.ts

@@ -0,0 +1,158 @@
+import {
+	type Component,
+	Container,
+	Input,
+	isArrowDown,
+	isArrowUp,
+	isEnter,
+	isEscape,
+	Spacer,
+	Text,
+	truncateToWidth,
+	visibleWidth,
+} from "@oh-my-pi/pi-tui";
+import type { HistoryEntry, HistoryStorage } from "../../../core/history-storage";
+import { theme } from "../theme/theme";
+import { DynamicBorder } from "./dynamic-border";
+
+class HistoryResultsList implements Component {
+	private results: HistoryEntry[] = [];
+	private selectedIndex = 0;
+	private maxVisible = 10;
+
+	setResults(results: HistoryEntry[], selectedIndex: number): void {
+		this.results = results;
+		this.selectedIndex = selectedIndex;
+	}
+
+	setSelectedIndex(selectedIndex: number): void {
+		this.selectedIndex = selectedIndex;
+	}
+
+	invalidate(): void {
+		// No cached state to invalidate currently
+	}
+
+	render(width: number): string[] {
+		const lines: string[] = [];
+
+		if (this.results.length === 0) {
+			lines.push(theme.fg("muted", "  No matching history"));
+			return lines;
+		}
+
+		const startIndex = Math.max(
+			0,
+			Math.min(this.selectedIndex - Math.floor(this.maxVisible / 2), this.results.length - this.maxVisible),
+		);
+		const endIndex = Math.min(startIndex + this.maxVisible, this.results.length);
+
+		for (let i = startIndex; i < endIndex; i++) {
+			const entry = this.results[i];
+			const isSelected = i === this.selectedIndex;
+
+			const cursorSymbol = `${theme.nav.cursor} `;
+			const cursorWidth = visibleWidth(cursorSymbol);
+			const cursor = isSelected ? theme.fg("accent", cursorSymbol) : " ".repeat(cursorWidth);
+			const maxWidth = width - cursorWidth;
+
+			const normalized = entry.prompt.replace(/\s+/g, " ").trim();
+			const truncated = truncateToWidth(normalized, maxWidth, theme.format.ellipsis);
+			lines.push(cursor + (isSelected ? theme.bold(truncated) : truncated));
+		}
+
+		if (startIndex > 0 || endIndex < this.results.length) {
+			const scrollText = `  (${this.selectedIndex + 1}/${this.results.length})`;
+			lines.push(theme.fg("muted", truncateToWidth(scrollText, width, "")));
+		}
+
+		return lines;
+	}
+}
+
+export class HistorySearchComponent extends Container {
+	private historyStorage: HistoryStorage;
+	private searchInput: Input;
+	private results: HistoryEntry[] = [];
+	private selectedIndex = 0;
+	private resultsList: HistoryResultsList;
+	private onSelect: (prompt: string) => void;
+	private onCancel: () => void;
+	private resultLimit = 100;
+
+	constructor(historyStorage: HistoryStorage, onSelect: (prompt: string) => void, onCancel: () => void) {
+		super();
+		this.historyStorage = historyStorage;
+		this.onSelect = onSelect;
+		this.onCancel = onCancel;
+
+		this.searchInput = new Input();
+		this.searchInput.onSubmit = () => {
+			const selected = this.results[this.selectedIndex];
+			if (selected) {
+				this.onSelect(selected.prompt);
+			}
+		};
+		this.searchInput.onEscape = () => {
+			this.onCancel();
+		};
+
+		this.resultsList = new HistoryResultsList();
+
+		this.addChild(new Spacer(1));
+		this.addChild(new Text(theme.bold("Search History (Ctrl+R)"), 1, 0));
+		this.addChild(new Spacer(1));
+		this.addChild(new DynamicBorder());
+		this.addChild(new Spacer(1));
+		this.addChild(this.searchInput);
+		this.addChild(new Spacer(1));
+		this.addChild(this.resultsList);
+		this.addChild(new Spacer(1));
+		this.addChild(new Text(theme.fg("muted", "up/down navigate  enter select  esc cancel"), 1, 0));
+		this.addChild(new Spacer(1));
+		this.addChild(new DynamicBorder());
+
+		this.updateResults();
+	}
+
+	handleInput(keyData: string): void {
+		if (isArrowUp(keyData)) {
+			if (this.results.length === 0) return;
+			this.selectedIndex = Math.max(0, this.selectedIndex - 1);
+			this.resultsList.setSelectedIndex(this.selectedIndex);
+			return;
+		}
+
+		if (isArrowDown(keyData)) {
+			if (this.results.length === 0) return;
+			this.selectedIndex = Math.min(this.results.length - 1, this.selectedIndex + 1);
+			this.resultsList.setSelectedIndex(this.selectedIndex);
+			return;
+		}
+
+		if (isEnter(keyData)) {
+			const selected = this.results[this.selectedIndex];
+			if (selected) {
+				this.onSelect(selected.prompt);
+			}
+			return;
+		}
+
+		if (isEscape(keyData)) {
+			this.onCancel();
+			return;
+		}
+
+		this.searchInput.handleInput(keyData);
+		this.updateResults();
+	}
+
+	private updateResults(): void {
+		const query = this.searchInput.getValue().trim();
+		this.results = query
+			? this.historyStorage.search(query, this.resultLimit)
+			: this.historyStorage.getRecent(this.resultLimit);
+		this.selectedIndex = 0;
+		this.resultsList.setResults(this.results, this.selectedIndex);
+	}
+}

package/src/modes/interactive/interactive-mode.ts

@@ -27,7 +27,9 @@ import { nanoid } from "nanoid";
 import { getAuthPath, getDebugLogPath } from "../../config";
 import type { AgentSession, AgentSessionEvent } from "../../core/agent-session";
 import type { ExtensionUIContext } from "../../core/extensions/index";
+import { HistoryStorage } from "../../core/history-storage";
 import { KeybindingsManager } from "../../core/keybindings";
+import { logger } from "../../core/logger";
 import { type CustomMessage, createCompactionSummaryMessage } from "../../core/messages";
 import { getRecentSessions, type SessionContext, SessionManager } from "../../core/session-manager";
 import { loadSlashCommands } from "../../core/slash-commands";
@@ -51,6 +53,7 @@ import { CustomEditor } from "./components/custom-editor";
 import { CustomMessageComponent } from "./components/custom-message";
 import { DynamicBorder } from "./components/dynamic-border";
 import { ExtensionDashboard } from "./components/extensions";
+import { HistorySearchComponent } from "./components/history-search";
 import { HookEditorComponent } from "./components/hook-editor";
 import { HookInputComponent } from "./components/hook-input";
 import { HookSelectorComponent } from "./components/hook-selector";
@@ -170,6 +173,8 @@ export class InteractiveMode {
 	// Slash commands loaded from files (for compaction queue handling)
 	private fileSlashCommands = new Set<string>();
 
+	private historyStorage?: HistoryStorage;
+
 	// Voice mode state
 	private voiceSupervisor: VoiceSupervisor;
 	private voiceAutoModeEnabled = false;
@@ -223,6 +228,12 @@ export class InteractiveMode {
 		this.statusContainer = new Container();
 		this.editor = new CustomEditor(getEditorTheme());
 		this.editor.setUseTerminalCursor(true);
+		try {
+			this.historyStorage = HistoryStorage.open();
+			this.editor.setHistoryStorage(this.historyStorage);
+		} catch (error) {
+			logger.warn("History storage unavailable", { error: String(error) });
+		}
 		this.editorContainer = new Container();
 		this.editorContainer.addChild(this.editor);
 		this.statusLine = new StatusLineComponent(session);
@@ -1047,6 +1058,7 @@ export class InteractiveMode {
 		// Global debug handler on TUI (works regardless of focus)
 		this.ui.onDebug = () => this.handleDebugCommand();
 		this.editor.onCtrlL = () => this.showModelSelector();
+		this.editor.onCtrlR = () => this.showHistorySearch();
 		this.editor.onCtrlO = () => this.toggleToolOutputExpansion();
 		this.editor.onCtrlT = () => this.toggleThinkingBlockVisibility();
 		this.editor.onCtrlG = () => this.openExternalEditor();
@@ -2500,6 +2512,27 @@ export class InteractiveMode {
 		});
 	}
 
+	private showHistorySearch(): void {
+		const historyStorage = this.historyStorage;
+		if (!historyStorage) return;
+
+		this.showSelector((done) => {
+			const component = new HistorySearchComponent(
+				historyStorage,
+				(prompt) => {
+					done();
+					this.editor.setText(prompt);
+					this.ui.requestRender();
+				},
+				() => {
+					done();
+					this.ui.requestRender();
+				},
+			);
+			return { component, focus: component };
+		});
+	}
+
 	/**
 	 * Show the Extension Control Center dashboard.
 	 * Replaces /status with a unified view of all providers and extensions.
@@ -3261,6 +3294,7 @@ export class InteractiveMode {
 | \`Shift+Ctrl+P\` | Cycle role models (temporary) |
 | \`Ctrl+Y\` | Select model (temporary) |
 | \`Ctrl+L\` | Select model (set roles) |
+| \`Ctrl+R\` | Search prompt history |
 | \`Ctrl+O\` | Toggle tool output expansion |
 | \`Ctrl+T\` | Toggle thinking block visibility |
 | \`Ctrl+G\` | Edit message in external editor |