pi-ui-extend 0.1.13 → 0.1.17

package/dist/app/session/lazy-session-manager.js

@@ -0,0 +1,539 @@
+import { randomUUID } from "node:crypto";
+import { appendFileSync, closeSync, createReadStream, existsSync, mkdirSync, openSync, readSync, statSync, writeFileSync } from "node:fs";
+import { open as openFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { createInterface } from "node:readline";
+import { buildSessionContext, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { isRecord } from "../guards.js";
+const CURRENT_SESSION_VERSION = 3;
+const DEFAULT_TAIL_ENTRY_COUNT = 180;
+const INITIAL_TAIL_BYTES = 256 * 1024;
+const MAX_TAIL_BYTES = 16 * 1024 * 1024;
+export function openLazySessionManager(sessionPath, options = {}) {
+    return new LazySessionManager(sessionPath, options);
+}
+class LazySessionManager {
+    sessionFilePath;
+    sessionDirPath;
+    cwdPath;
+    header;
+    entries = [];
+    byId = new Map();
+    labelsById = new Map();
+    labelTimestampsById = new Map();
+    leafId = null;
+    hydrated;
+    tailEntryCount;
+    tailStartOffset = 0;
+    constructor(sessionPath, options = {}) {
+        this.sessionFilePath = resolve(sessionPath);
+        this.sessionDirPath = resolve(options.sessionDir ?? dirname(this.sessionFilePath));
+        this.tailEntryCount = Math.max(1, Math.floor(options.tailEntryCount ?? DEFAULT_TAIL_ENTRY_COUNT));
+        this.header = this.loadHeader(options.cwdOverride);
+        this.cwdPath = resolve(options.cwdOverride ?? this.header.cwd ?? process.cwd());
+        this.loadTailEntries();
+    }
+    setSessionFile(sessionFile) {
+        if (this.hydrated) {
+            this.hydrated.setSessionFile(sessionFile);
+            return;
+        }
+        this.sessionFilePath = resolve(sessionFile);
+        this.sessionDirPath = dirname(this.sessionFilePath);
+        this.header = this.loadHeader(this.cwdPath);
+        this.cwdPath = resolve(this.header.cwd || this.cwdPath);
+        this.loadTailEntries();
+    }
+    newSession(options) {
+        if (this.hydrated)
+            return this.hydrated.newSession(options);
+        const timestamp = new Date().toISOString();
+        const sessionId = options?.id ?? createSessionId();
+        const header = {
+            type: "session",
+            version: CURRENT_SESSION_VERSION,
+            id: sessionId,
+            timestamp,
+            cwd: this.cwdPath,
+        };
+        if (options?.parentSession !== undefined)
+            header.parentSession = options.parentSession;
+        this.header = header;
+        this.entries = [];
+        this.byId.clear();
+        this.labelsById.clear();
+        this.labelTimestampsById.clear();
+        this.leafId = null;
+        mkdirSync(this.sessionDirPath, { recursive: true });
+        this.sessionFilePath = join(this.sessionDirPath, `${timestamp.replace(/[:.]/g, "-")}_${sessionId}.jsonl`);
+        writeFileSync(this.sessionFilePath, `${JSON.stringify(header)}\n`, "utf8");
+        return this.sessionFilePath;
+    }
+    isPersisted() {
+        return true;
+    }
+    getCwd() {
+        return this.hydrated?.getCwd() ?? this.cwdPath;
+    }
+    getSessionDir() {
+        return this.hydrated?.getSessionDir() ?? this.sessionDirPath;
+    }
+    usesDefaultSessionDir() {
+        return this.hydrated?.usesDefaultSessionDir() ?? false;
+    }
+    getSessionId() {
+        return this.hydrated?.getSessionId() ?? this.header.id;
+    }
+    getSessionFile() {
+        return this.hydrated?.getSessionFile() ?? this.sessionFilePath;
+    }
+    getHeader() {
+        return this.hydrated?.getHeader() ?? this.header;
+    }
+    getEntries() {
+        return this.hydrated?.getEntries() ?? [...this.entries];
+    }
+    getBranch(fromId) {
+        if (this.hydrated)
+            return this.hydrated.getBranch(fromId);
+        if (fromId === undefined)
+            return [...this.entries];
+        if (fromId !== undefined && !this.byId.has(fromId))
+            return this.hydrate().getBranch(fromId);
+        return [...this.entries];
+    }
+    createHistoryReader() {
+        if (this.hydrated || this.tailStartOffset <= 0)
+            return undefined;
+        let cursorOffset = this.tailStartOffset;
+        const firstEntryOffset = readFirstSessionEntryOffset(this.sessionFilePath);
+        return {
+            hasOlder: () => cursorOffset > firstEntryOffset,
+            readOlder: async (limit) => {
+                if (cursorOffset <= firstEntryOffset)
+                    return [];
+                const result = await readSessionEntriesBeforeOffset(this.sessionFilePath, cursorOffset, Math.max(1, Math.floor(limit)));
+                cursorOffset = result.startOffset;
+                if (result.entries.length === 0)
+                    cursorOffset = firstEntryOffset;
+                return result.entries;
+            },
+        };
+    }
+    async readFullBranchEntries() {
+        if (this.hydrated)
+            return this.hydrated.getBranch();
+        const entries = await readAllSessionEntries(this.sessionFilePath);
+        return branchEntries(entries, this.leafId ?? entries.at(-1)?.id);
+    }
+    buildSessionContext() {
+        if (this.hydrated)
+            return this.hydrated.buildSessionContext();
+        const entries = this.contextEntries();
+        const byId = new Map(entries.map((entry) => [entry.id, entry]));
+        return buildSessionContext(entries, entries.at(-1)?.id ?? null, byId);
+    }
+    getSessionName() {
+        if (this.hydrated)
+            return this.hydrated.getSessionName();
+        for (let index = this.entries.length - 1; index >= 0; index -= 1) {
+            const entry = this.entries[index];
+            if (entry?.type === "session_info")
+                return entry.name?.trim() || undefined;
+        }
+        return undefined;
+    }
+    getLeafId() {
+        return this.hydrated?.getLeafId() ?? this.leafId;
+    }
+    getLeafEntry() {
+        if (this.hydrated)
+            return this.hydrated.getLeafEntry();
+        return this.leafId ? this.byId.get(this.leafId) : undefined;
+    }
+    getEntry(id) {
+        if (this.hydrated)
+            return this.hydrated.getEntry(id);
+        return this.byId.get(id) ?? this.hydrate().getEntry(id);
+    }
+    getChildren(parentId) {
+        if (this.hydrated)
+            return this.hydrated.getChildren(parentId);
+        return this.entries.filter((entry) => entry.parentId === parentId);
+    }
+    getLabel(id) {
+        return this.hydrated?.getLabel(id) ?? this.labelsById.get(id);
+    }
+    getTree() {
+        return this.hydrate().getTree();
+    }
+    branch(branchFromId) {
+        if (!this.byId.has(branchFromId)) {
+            this.hydrate().branch(branchFromId);
+            return;
+        }
+        this.leafId = branchFromId;
+    }
+    resetLeaf() {
+        if (this.hydrated) {
+            this.hydrated.resetLeaf();
+            return;
+        }
+        this.leafId = null;
+    }
+    createBranchedSession(leafId) {
+        return this.hydrate().createBranchedSession(leafId);
+    }
+    branchWithSummary(branchFromId, summary, details, fromHook) {
+        return this.hydrate().branchWithSummary(branchFromId, summary, details, fromHook);
+    }
+    appendLabelChange(targetId, label) {
+        if (this.hydrated)
+            return this.hydrated.appendLabelChange(targetId, label);
+        if (!this.byId.has(targetId))
+            return this.hydrate().appendLabelChange(targetId, label);
+        const entry = this.newEntry("label", { targetId, label });
+        this.appendEntry(entry);
+        if (label) {
+            this.labelsById.set(targetId, label);
+            this.labelTimestampsById.set(targetId, entry.timestamp);
+        }
+        else {
+            this.labelsById.delete(targetId);
+            this.labelTimestampsById.delete(targetId);
+        }
+        return entry.id;
+    }
+    appendMessage(message) {
+        if (this.hydrated)
+            return this.hydrated.appendMessage(message);
+        return this.appendEntry(this.newEntry("message", { message }));
+    }
+    appendThinkingLevelChange(thinkingLevel) {
+        if (this.hydrated)
+            return this.hydrated.appendThinkingLevelChange(thinkingLevel);
+        return this.appendEntry(this.newEntry("thinking_level_change", { thinkingLevel }));
+    }
+    appendModelChange(provider, modelId) {
+        if (this.hydrated)
+            return this.hydrated.appendModelChange(provider, modelId);
+        return this.appendEntry(this.newEntry("model_change", { provider, modelId }));
+    }
+    appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromHook) {
+        if (this.hydrated)
+            return this.hydrated.appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromHook);
+        const payload = { summary, firstKeptEntryId, tokensBefore };
+        if (details !== undefined)
+            payload.details = details;
+        if (fromHook !== undefined)
+            payload.fromHook = fromHook;
+        return this.appendEntry(this.newEntry("compaction", payload));
+    }
+    appendCustomEntry(customType, data) {
+        if (this.hydrated)
+            return this.hydrated.appendCustomEntry(customType, data);
+        const payload = { customType };
+        if (data !== undefined)
+            payload.data = data;
+        return this.appendEntry(this.newEntry("custom", payload));
+    }
+    appendSessionInfo(name) {
+        if (this.hydrated)
+            return this.hydrated.appendSessionInfo(name);
+        return this.appendEntry(this.newEntry("session_info", { name: name.trim() }));
+    }
+    appendCustomMessageEntry(customType, content, display, details) {
+        if (this.hydrated)
+            return this.hydrated.appendCustomMessageEntry(customType, content, display, details);
+        const payload = { customType, content, display };
+        if (details !== undefined)
+            payload.details = details;
+        return this.appendEntry(this.newEntry("custom_message", payload));
+    }
+    hydrate() {
+        if (!this.hydrated) {
+            this.hydrated = SessionManager.open(this.sessionFilePath, this.sessionDirPath, this.cwdPath);
+        }
+        return this.hydrated;
+    }
+    loadHeader(cwdOverride) {
+        if (!existsSync(this.sessionFilePath)) {
+            mkdirSync(dirname(this.sessionFilePath), { recursive: true });
+            const header = createSessionHeader(resolve(cwdOverride ?? process.cwd()));
+            writeFileSync(this.sessionFilePath, `${JSON.stringify(header)}\n`, "utf8");
+            return header;
+        }
+        const header = readSessionHeaderFast(this.sessionFilePath);
+        return header ?? createSessionHeader(resolve(cwdOverride ?? process.cwd()));
+    }
+    loadTailEntries() {
+        const result = readTailSessionEntries(this.sessionFilePath, this.tailEntryCount);
+        this.entries = result.entries;
+        this.tailStartOffset = result.startOffset;
+        this.rebuildIndexes();
+    }
+    rebuildIndexes() {
+        this.byId.clear();
+        this.labelsById.clear();
+        this.labelTimestampsById.clear();
+        this.leafId = null;
+        for (const entry of this.entries) {
+            this.byId.set(entry.id, entry);
+            this.leafId = entry.id;
+            if (entry.type === "label") {
+                if (entry.label) {
+                    this.labelsById.set(entry.targetId, entry.label);
+                    this.labelTimestampsById.set(entry.targetId, entry.timestamp);
+                }
+                else {
+                    this.labelsById.delete(entry.targetId);
+                    this.labelTimestampsById.delete(entry.targetId);
+                }
+            }
+        }
+    }
+    appendEntry(entry) {
+        this.entries.push(entry);
+        this.byId.set(entry.id, entry);
+        this.leafId = entry.id;
+        appendFileSync(this.sessionFilePath, `${JSON.stringify(entry)}\n`, "utf8");
+        return entry.id;
+    }
+    newEntry(type, payload) {
+        return {
+            type,
+            id: this.createEntryId(),
+            parentId: this.leafId,
+            timestamp: new Date().toISOString(),
+            ...payload,
+        };
+    }
+    createEntryId() {
+        for (let attempt = 0; attempt < 100; attempt += 1) {
+            const id = randomUUID().slice(0, 8);
+            if (!this.byId.has(id))
+                return id;
+        }
+        return randomUUID();
+    }
+    contextEntries() {
+        const entries = this.entries.filter((entry) => entry.type !== "label");
+        const start = contextStartIndex(entries);
+        const selected = entries.slice(start);
+        return selected.map((entry, index) => ({
+            ...entry,
+            parentId: index === 0 ? null : selected[index - 1].id,
+        }));
+    }
+}
+function createSessionHeader(cwd) {
+    return {
+        type: "session",
+        version: CURRENT_SESSION_VERSION,
+        id: createSessionId(),
+        timestamp: new Date().toISOString(),
+        cwd,
+    };
+}
+function createSessionId() {
+    return randomUUID();
+}
+function readSessionHeaderFast(filePath) {
+    const line = readFirstLine(filePath, 64 * 1024);
+    if (!line)
+        return undefined;
+    try {
+        const parsed = JSON.parse(line);
+        if (!isRecord(parsed) || parsed.type !== "session" || typeof parsed.id !== "string")
+            return undefined;
+        const header = parsed;
+        return typeof header.cwd === "string" ? header : { ...header, cwd: process.cwd() };
+    }
+    catch {
+        return undefined;
+    }
+}
+function readFirstLine(filePath, maxBytes) {
+    let fd;
+    try {
+        fd = openSync(filePath, "r");
+        const buffer = Buffer.alloc(maxBytes);
+        const bytesRead = readSync(fd, buffer, 0, buffer.length, 0);
+        const text = buffer.toString("utf8", 0, bytesRead);
+        return text.split("\n")[0];
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+    }
+}
+function readFirstSessionEntryOffset(filePath) {
+    let fd;
+    try {
+        fd = openSync(filePath, "r");
+        const buffer = Buffer.alloc(64 * 1024);
+        const bytesRead = readSync(fd, buffer, 0, buffer.length, 0);
+        const entries = parseSessionEntryBufferLines(buffer.subarray(0, bytesRead), 0);
+        return entries[0]?.offset ?? 0;
+    }
+    catch {
+        return 0;
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+    }
+}
+function readTailSessionEntries(filePath, limit) {
+    if (!existsSync(filePath))
+        return { entries: [], startOffset: 0 };
+    const size = statSync(filePath).size;
+    if (size <= 0)
+        return { entries: [], startOffset: 0 };
+    let byteCount = Math.min(size, INITIAL_TAIL_BYTES);
+    const maxBytes = Math.min(size, MAX_TAIL_BYTES);
+    while (byteCount <= maxBytes) {
+        const result = readTailSessionEntriesWithByteCount(filePath, byteCount, limit);
+        if (result.entries.length >= limit || byteCount >= maxBytes || byteCount >= size)
+            return result;
+        byteCount = Math.min(size, Math.max(byteCount + 1, byteCount * 2));
+    }
+    return { entries: [], startOffset: 0 };
+}
+function readTailSessionEntriesWithByteCount(filePath, byteCount, limit) {
+    let fd;
+    try {
+        const size = statSync(filePath).size;
+        const start = Math.max(0, size - byteCount);
+        const buffer = Buffer.alloc(size - start);
+        fd = openSync(filePath, "r");
+        readSync(fd, buffer, 0, buffer.length, start);
+        let parseStart = 0;
+        if (start > 0) {
+            const firstNewline = buffer.indexOf(10);
+            parseStart = firstNewline >= 0 ? firstNewline + 1 : buffer.length;
+        }
+        return selectLastSessionEntries(parseSessionEntryBufferLines(buffer.subarray(parseStart), start + parseStart), limit, size);
+    }
+    catch {
+        return { entries: [], startOffset: 0 };
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+    }
+}
+async function readSessionEntriesBeforeOffset(filePath, endOffset, limit) {
+    if (!existsSync(filePath) || endOffset <= 0)
+        return { entries: [], startOffset: 0 };
+    let byteCount = Math.min(endOffset, INITIAL_TAIL_BYTES);
+    const maxBytes = Math.min(endOffset, MAX_TAIL_BYTES);
+    while (byteCount <= maxBytes) {
+        const result = await readSessionEntriesBeforeOffsetWithByteCount(filePath, endOffset, byteCount, limit);
+        if (result.entries.length >= limit || byteCount >= maxBytes || byteCount >= endOffset)
+            return result;
+        byteCount = Math.min(endOffset, Math.max(byteCount + 1, byteCount * 2));
+    }
+    return { entries: [], startOffset: 0 };
+}
+async function readSessionEntriesBeforeOffsetWithByteCount(filePath, endOffset, byteCount, limit) {
+    let file;
+    try {
+        const start = Math.max(0, endOffset - byteCount);
+        const buffer = Buffer.alloc(endOffset - start);
+        file = await openFile(filePath, "r");
+        await file.read(buffer, 0, buffer.length, start);
+        let parseStart = 0;
+        if (start > 0) {
+            const firstNewline = buffer.indexOf(10);
+            parseStart = firstNewline >= 0 ? firstNewline + 1 : buffer.length;
+        }
+        return selectLastSessionEntries(parseSessionEntryBufferLines(buffer.subarray(parseStart), start + parseStart), limit, start);
+    }
+    catch {
+        return { entries: [], startOffset: 0 };
+    }
+    finally {
+        await file?.close();
+    }
+}
+function selectLastSessionEntries(parsedEntries, limit, emptyStartOffset) {
+    const selected = parsedEntries.slice(-limit);
+    return {
+        entries: selected.map((item) => item.entry),
+        startOffset: selected[0]?.offset ?? emptyStartOffset,
+    };
+}
+function parseSessionEntryBufferLines(buffer, baseOffset) {
+    const entries = [];
+    let lineStart = 0;
+    for (let index = 0; index <= buffer.length; index += 1) {
+        if (index < buffer.length && buffer[index] !== 10)
+            continue;
+        const lineEnd = index > lineStart && buffer[index - 1] === 13 ? index - 1 : index;
+        const entry = parseSessionEntryLine(buffer.toString("utf8", lineStart, lineEnd));
+        if (entry)
+            entries.push({ entry, offset: baseOffset + lineStart });
+        lineStart = index + 1;
+    }
+    return entries;
+}
+function parseSessionEntryLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return undefined;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (!isRecord(parsed) || parsed.type === "session" || typeof parsed.id !== "string")
+            return undefined;
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function readAllSessionEntries(filePath) {
+    if (!existsSync(filePath))
+        return [];
+    const entries = [];
+    const lines = createInterface({ input: createReadStream(filePath, { encoding: "utf8" }), crlfDelay: Infinity });
+    for await (const line of lines) {
+        const entry = parseSessionEntryLine(line);
+        if (entry)
+            entries.push(entry);
+    }
+    return entries;
+}
+function branchEntries(entries, leafId) {
+    if (!leafId)
+        return [...entries];
+    const byId = new Map(entries.map((entry) => [entry.id, entry]));
+    const branch = [];
+    const seen = new Set();
+    let cursor = leafId;
+    while (cursor && !seen.has(cursor)) {
+        seen.add(cursor);
+        const entry = byId.get(cursor);
+        if (!entry)
+            break;
+        branch.push(entry);
+        cursor = entry.parentId;
+    }
+    return branch.reverse();
+}
+function contextStartIndex(entries) {
+    const userIndex = entries.findIndex((entry) => entry.type === "message" && entry.message.role === "user");
+    if (userIndex < 0)
+        return 0;
+    let start = userIndex;
+    while (start > 0) {
+        const previous = entries[start - 1];
+        if (!previous || (previous.type !== "model_change" && previous.type !== "thinking_level_change" && previous.type !== "compaction" && previous.type !== "branch_summary" && previous.type !== "custom"))
+            break;
+        start -= 1;
+    }
+    return start;
+}

package/dist/app/session/pix-system-message.d.ts

@@ -0,0 +1,16 @@
+import type { AgentSession, SessionEntry } from "@earendil-works/pi-coding-agent";
+export declare const PIX_SYSTEM_MESSAGE_CUSTOM_TYPE = "pix-system";
+export declare const PIX_SYSTEM_DISPLAY_ENTRY_CUSTOM_TYPE = "pix:system_message";
+export declare const PIX_SESSION_ENTRY_ID_FIELD = "__pixSessionEntryId";
+export declare function appendPixSystemDisplayEntry(session: AgentSession, text: string): void;
+export declare function sessionHistoryDisplayMessages(session: AgentSession): readonly unknown[];
+export type SessionHistoryOlderMessagesReader = {
+    hasOlder(): boolean;
+    readOlder(limit: number): Promise<readonly unknown[]>;
+};
+export declare function sessionHistoryOlderMessagesReader(session: AgentSession): SessionHistoryOlderMessagesReader | undefined;
+export declare function sessionHistoryDisplayMessagesFromEntries(branch: readonly SessionEntry[]): readonly unknown[];
+export type FullBranchSessionEntryReader = {
+    readFullBranchEntries(): Promise<readonly SessionEntry[]>;
+};
+export declare function sessionHistoryFullBranchEntries(session: AgentSession): Promise<readonly SessionEntry[]>;

package/dist/app/session/pix-system-message.js

@@ -0,0 +1,64 @@
+import { isRecord } from "../guards.js";
+export const PIX_SYSTEM_MESSAGE_CUSTOM_TYPE = "pix-system";
+export const PIX_SYSTEM_DISPLAY_ENTRY_CUSTOM_TYPE = "pix:system_message";
+export const PIX_SESSION_ENTRY_ID_FIELD = "__pixSessionEntryId";
+export function appendPixSystemDisplayEntry(session, text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return;
+    session.sessionManager.appendCustomEntry(PIX_SYSTEM_DISPLAY_ENTRY_CUSTOM_TYPE, { text: trimmed });
+}
+export function sessionHistoryDisplayMessages(session) {
+    const branch = session.sessionManager.getBranch();
+    if (branch.length === 0)
+        return session.messages;
+    return sessionHistoryDisplayMessagesFromEntries(branch);
+}
+export function sessionHistoryOlderMessagesReader(session) {
+    const reader = session.sessionManager.createHistoryReader?.();
+    if (!reader)
+        return undefined;
+    return {
+        hasOlder: () => reader.hasOlder(),
+        readOlder: async (limit) => sessionHistoryDisplayMessagesFromEntries(await reader.readOlder(limit)),
+    };
+}
+export function sessionHistoryDisplayMessagesFromEntries(branch) {
+    const messages = [];
+    for (const entry of branch) {
+        if (entry.type === "message") {
+            messages.push(withSessionEntryId(entry.message, entry.id));
+        }
+        else if (entry.type === "custom_message") {
+            messages.push({
+                role: "custom",
+                customType: entry.customType,
+                content: entry.content,
+                display: entry.display,
+            });
+        }
+        else if (isPixSystemDisplayEntry(entry)) {
+            messages.push({
+                role: "custom",
+                customType: PIX_SYSTEM_MESSAGE_CUSTOM_TYPE,
+                content: entry.data.text,
+                display: true,
+            });
+        }
+    }
+    return messages;
+}
+export async function sessionHistoryFullBranchEntries(session) {
+    const reader = session.sessionManager;
+    return await reader.readFullBranchEntries?.() ?? session.sessionManager.getBranch();
+}
+function withSessionEntryId(message, entryId) {
+    return isRecord(message) ? { ...message, [PIX_SESSION_ENTRY_ID_FIELD]: entryId } : message;
+}
+function isPixSystemDisplayEntry(entry) {
+    return entry.type === "custom"
+        && entry.customType === PIX_SYSTEM_DISPLAY_ENTRY_CUSTOM_TYPE
+        && isRecord(entry.data)
+        && typeof entry.data.text === "string"
+        && entry.data.text.trim().length > 0;
+}

package/dist/app/session/request-history.d.ts

@@ -1,3 +1,4 @@
+import { type FuzzyMatch } from "../../fuzzy.js";
 export type RequestHistoryHost = {
     readonly noSession: boolean;
     getInput(): string;
@@ -5,6 +6,7 @@ export type RequestHistoryHost = {
     resetInputMenuDismissals(): void;
     render(): void;
 };
+export type RequestHistorySearchMatch = FuzzyMatch<string>;
 export declare class AppRequestHistory {
     private readonly host;
     private entries;
@@ -13,6 +15,8 @@ export declare class AppRequestHistory {
     constructor(host: RequestHistoryHost);
     load(): Promise<void>;
     add(text: string): void;
+    search(query: string, limit?: number): string[];
+    searchMatches(query: string, limit?: number): RequestHistorySearchMatch[];
     resetNavigation(): void;
     navigate(direction: -1 | 1): boolean;
     private save;

package/dist/app/session/request-history.js

@@ -1,6 +1,7 @@
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { fuzzySearch } from "../../fuzzy.js";
 import { REQUEST_HISTORY_MAX_BYTES, REQUEST_HISTORY_MAX_ENTRIES, REQUEST_HISTORY_MAX_ENTRY_BYTES, REQUEST_HISTORY_VERSION, } from "../constants.js";
 import { isRecord } from "../guards.js";
 export class AppRequestHistory {
@@ -40,6 +41,16 @@ export class AppRequestHistory {
         this.entries = this.limited([...this.entries, normalized]);
         void this.save();
     }
+    search(query, limit = 50) {
+        return this.searchMatches(query, limit).map((match) => match.value);
+    }
+    searchMatches(query, limit = 50) {
+        const items = [...this.entries].reverse().map((entry) => ({
+            value: entry,
+            label: entry,
+        }));
+        return fuzzySearch(items, query, { limit, minScorePerCharacter: 8, preferKeyboardLayoutMatches: true });
+    }
     resetNavigation() {
         this.cursor = undefined;
         this.draft = "";