@timurproko/a1 0.1.8-dev.289 → 0.1.8-dev.299

package/dist/integrations/pi/components/upstream/history/kill-ring.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Adapted from @earendil-works/pi-tui 0.84.2, packages/tui/src/kill-ring.ts (MIT).
+ * Source commit: 914cf1472e715297caa30db4b9535d534a9eb718.
+ * Modifications: public imports and owned editor-local typed seams; see docs/architecture/history-editor-provenance.md.
+ */
+/**
+ * Ring buffer for Emacs-style kill/yank operations.
+ *
+ * Tracks killed (deleted) text entries. Consecutive kills can accumulate
+ * into a single entry. Supports yank (paste most recent) and yank-pop
+ * (cycle through older entries).
+ */
+export declare class KillRing {
+    private ring;
+    /**
+     * Add text to the kill ring.
+     *
+     * @param text - The killed text to add
+     * @param opts - Push options
+     * @param opts.prepend - If accumulating, prepend (backward deletion) or append (forward deletion)
+     * @param opts.accumulate - Merge with the most recent entry instead of creating a new one
+     */
+    push(text: string, opts: {
+        prepend: boolean;
+        accumulate?: boolean;
+    }): void;
+    /** Get most recent entry without modifying the ring. */
+    peek(): string | undefined;
+    /** Move last entry to front (for yank-pop cycling). */
+    rotate(): void;
+    get length(): number;
+}

package/dist/integrations/pi/components/upstream/history/kill-ring.js

@@ -0,0 +1,48 @@
+/**
+ * Adapted from @earendil-works/pi-tui 0.84.2, packages/tui/src/kill-ring.ts (MIT).
+ * Source commit: 914cf1472e715297caa30db4b9535d534a9eb718.
+ * Modifications: public imports and owned editor-local typed seams; see docs/architecture/history-editor-provenance.md.
+ */
+/**
+ * Ring buffer for Emacs-style kill/yank operations.
+ *
+ * Tracks killed (deleted) text entries. Consecutive kills can accumulate
+ * into a single entry. Supports yank (paste most recent) and yank-pop
+ * (cycle through older entries).
+ */
+export class KillRing {
+    ring = [];
+    /**
+     * Add text to the kill ring.
+     *
+     * @param text - The killed text to add
+     * @param opts - Push options
+     * @param opts.prepend - If accumulating, prepend (backward deletion) or append (forward deletion)
+     * @param opts.accumulate - Merge with the most recent entry instead of creating a new one
+     */
+    push(text, opts) {
+        if (!text)
+            return;
+        if (opts.accumulate && this.ring.length > 0) {
+            const last = this.ring.pop();
+            this.ring.push(opts.prepend ? text + last : last + text);
+        }
+        else {
+            this.ring.push(text);
+        }
+    }
+    /** Get most recent entry without modifying the ring. */
+    peek() {
+        return this.ring.length > 0 ? this.ring[this.ring.length - 1] : undefined;
+    }
+    /** Move last entry to front (for yank-pop cycling). */
+    rotate() {
+        if (this.ring.length > 1) {
+            const last = this.ring.pop();
+            this.ring.unshift(last);
+        }
+    }
+    get length() {
+        return this.ring.length;
+    }
+}

package/dist/integrations/pi/components/upstream/history/printable-key.d.ts

@@ -0,0 +1 @@
+export declare function decodePrintableKey(data: string): string | undefined;

package/dist/integrations/pi/components/upstream/history/printable-key.js

@@ -0,0 +1,40 @@
+/**
+ * Adapted from @earendil-works/pi-tui 0.84.2, packages/tui/src/keys.ts (MIT).
+ * Source commit: 914cf1472e715297caa30db4b9535d534a9eb718.
+ * Modifications: public imports and owned editor-local typed seams; see docs/architecture/history-editor-provenance.md.
+ */
+import { decodeKittyPrintable } from "#pi-tui";
+const MODIFIERS = {
+    shift: 1,
+    alt: 2,
+    ctrl: 4,
+    super: 8,
+};
+const LOCK_MASK = 64 + 128;
+function parseModifyOtherKeysSequence(data) {
+    const match = data.match(/^\x1b\[27;(\d+);(\d+)~$/);
+    if (!match)
+        return null;
+    const modValue = parseInt(match[1], 10);
+    const codepoint = parseInt(match[2], 10);
+    return { codepoint, modifier: modValue - 1 };
+}
+function decodeModifyOtherKeysPrintable(data) {
+    const parsed = parseModifyOtherKeysSequence(data);
+    if (!parsed)
+        return undefined;
+    const modifier = parsed.modifier & ~LOCK_MASK;
+    if ((modifier & ~MODIFIERS.shift) !== 0)
+        return undefined;
+    if (!Number.isFinite(parsed.codepoint) || parsed.codepoint < 32)
+        return undefined;
+    try {
+        return String.fromCodePoint(parsed.codepoint);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function decodePrintableKey(data) {
+    return decodeKittyPrintable(data) ?? decodeModifyOtherKeysPrintable(data);
+}

package/dist/integrations/pi/components/upstream/history/text-helpers.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Get the shared grapheme segmenter instance.
+ */
+export declare function getGraphemeSegmenter(): Intl.Segmenter;
+/**
+ * Get the shared word segmenter instance.
+ */
+export declare function getWordSegmenter(): Intl.Segmenter;
+export declare const cjkBreakRegex: RegExp;
+export declare const PUNCTUATION_REGEX: RegExp;
+/**
+ * Check if a character is whitespace.
+ */
+export declare function isWhitespaceChar(char: string): boolean;

package/dist/integrations/pi/components/upstream/history/text-helpers.js

@@ -0,0 +1,28 @@
+/**
+ * Adapted from @earendil-works/pi-tui 0.84.2, packages/tui/src/utils.ts (MIT).
+ * Source commit: 914cf1472e715297caa30db4b9535d534a9eb718.
+ * Modifications: public imports and owned editor-local typed seams; see docs/architecture/history-editor-provenance.md.
+ */
+// segmenters (shared instance)
+const graphemeSegmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+const wordSegmenter = new Intl.Segmenter(undefined, { granularity: "word" });
+/**
+ * Get the shared grapheme segmenter instance.
+ */
+export function getGraphemeSegmenter() {
+    return graphemeSegmenter;
+}
+/**
+ * Get the shared word segmenter instance.
+ */
+export function getWordSegmenter() {
+    return wordSegmenter;
+}
+export const cjkBreakRegex = /[\p{Script_Extensions=Han}\p{Script_Extensions=Hiragana}\p{Script_Extensions=Katakana}\p{Script_Extensions=Hangul}\p{Script_Extensions=Bopomofo}]/u;
+export const PUNCTUATION_REGEX = /[(){}[\]<>.,;:'"!?+\-=*/\\|&%^$#@~`]/;
+/**
+ * Check if a character is whitespace.
+ */
+export function isWhitespaceChar(char) {
+    return /\s/.test(char);
+}

package/dist/integrations/pi/components/upstream/history/undo-stack.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Adapted from @earendil-works/pi-tui 0.84.2, packages/tui/src/undo-stack.ts (MIT).
+ * Source commit: 914cf1472e715297caa30db4b9535d534a9eb718.
+ * Modifications: public imports and owned editor-local typed seams; see docs/architecture/history-editor-provenance.md.
+ */
+/**
+ * Generic undo stack with clone-on-push semantics.
+ *
+ * Stores deep clones of state snapshots. Popped snapshots are returned
+ * directly (no re-cloning) since they are already detached.
+ */
+export declare class UndoStack<S> {
+    private stack;
+    /** Push a deep clone of the given state onto the stack. */
+    push(state: S): void;
+    /** Pop and return the most recent snapshot, or undefined if empty. */
+    pop(): S | undefined;
+    /** Remove all snapshots. */
+    clear(): void;
+    updateSnapshots(update: (snapshot: S) => void): void;
+    get length(): number;
+}

package/dist/integrations/pi/components/upstream/history/undo-stack.js

@@ -0,0 +1,36 @@
+/**
+ * Adapted from @earendil-works/pi-tui 0.84.2, packages/tui/src/undo-stack.ts (MIT).
+ * Source commit: 914cf1472e715297caa30db4b9535d534a9eb718.
+ * Modifications: public imports and owned editor-local typed seams; see docs/architecture/history-editor-provenance.md.
+ */
+/**
+ * Generic undo stack with clone-on-push semantics.
+ *
+ * Stores deep clones of state snapshots. Popped snapshots are returned
+ * directly (no re-cloning) since they are already detached.
+ */
+export class UndoStack {
+    stack = [];
+    /** Push a deep clone of the given state onto the stack. */
+    push(state) {
+        this.stack.push(structuredClone(state));
+    }
+    /** Pop and return the most recent snapshot, or undefined if empty. */
+    pop() {
+        return this.stack.pop();
+    }
+    /** Remove all snapshots. */
+    clear() {
+        this.stack.length = 0;
+    }
+    updateSnapshots(update) {
+        this.stack = this.stack.map(snapshot => {
+            const copy = structuredClone(snapshot);
+            update(copy);
+            return copy;
+        });
+    }
+    get length() {
+        return this.stack.length;
+    }
+}

package/dist/integrations/pi/components/upstream/history/word-navigation.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Options for word navigation functions.
+ * When omitted, uses the default Intl.Segmenter word segmentation.
+ */
+export interface WordNavigationOptions {
+    /** Custom segmenter returning word segments for the given text. */
+    segment?: (text: string) => Iterable<Intl.SegmentData>;
+    /** Predicate identifying atomic segments that should be treated as single units (e.g. paste markers). */
+    isAtomicSegment?: (segment: string) => boolean;
+}
+/**
+ * Find the cursor position after moving one word backward from `cursor` in `text`.
+ * Skips trailing whitespace, then stops at the next word/punctuation boundary.
+ *
+ * Pure function - does not mutate any state.
+ */
+export declare function findWordBackward(text: string, cursor: number, options?: WordNavigationOptions): number;
+/**
+ * Find the cursor position after moving one word forward from `cursor` in `text`.
+ * Skips leading whitespace, then stops at the next word/punctuation boundary.
+ *
+ * Pure function - does not mutate any state.
+ */
+export declare function findWordForward(text: string, cursor: number, options?: WordNavigationOptions): number;

package/dist/integrations/pi/components/upstream/history/word-navigation.js

@@ -0,0 +1,100 @@
+/**
+ * Adapted from @earendil-works/pi-tui 0.84.2, packages/tui/src/word-navigation.ts (MIT).
+ * Source commit: 914cf1472e715297caa30db4b9535d534a9eb718.
+ * Modifications: public imports and owned editor-local typed seams; see docs/architecture/history-editor-provenance.md.
+ */
+import { getWordSegmenter, isWhitespaceChar, PUNCTUATION_REGEX } from "./text-helpers.js";
+const wordSegmenter = getWordSegmenter();
+/**
+ * Find the cursor position after moving one word backward from `cursor` in `text`.
+ * Skips trailing whitespace, then stops at the next word/punctuation boundary.
+ *
+ * Pure function - does not mutate any state.
+ */
+export function findWordBackward(text, cursor, options) {
+    if (cursor <= 0)
+        return 0;
+    const textBeforeCursor = text.slice(0, cursor);
+    const segmentFn = options?.segment;
+    const isAtomic = options?.isAtomicSegment;
+    const segments = segmentFn ? [...segmentFn(textBeforeCursor)] : [...wordSegmenter.segment(textBeforeCursor)];
+    let newCursor = cursor;
+    // Skip trailing whitespace
+    while (segments.length > 0 &&
+        !isAtomic?.(segments[segments.length - 1]?.segment || "") &&
+        isWhitespaceChar(segments[segments.length - 1]?.segment || "")) {
+        newCursor -= segments.pop()?.segment.length || 0;
+    }
+    if (segments.length === 0)
+        return newCursor;
+    const last = segments[segments.length - 1];
+    if (isAtomic?.(last.segment)) {
+        // Skip one atomic segment.
+        newCursor -= last.segment.length;
+    }
+    else if (last.isWordLike) {
+        // Skip inside one word-like segment, preserving ASCII punctuation boundaries.
+        const segment = last.segment;
+        const matches = [...segment.matchAll(new RegExp(PUNCTUATION_REGEX, "g"))];
+        if (matches.length <= 0) {
+            newCursor -= segment.length;
+        }
+        else {
+            const lastMatch = matches[matches.length - 1];
+            newCursor -= segment.length - (lastMatch.index + lastMatch[0].length);
+        }
+    }
+    else {
+        // Skip non-word non-whitespace run (punctuation)
+        while (segments.length > 0 &&
+            !isAtomic?.(segments[segments.length - 1]?.segment || "") &&
+            !segments[segments.length - 1]?.isWordLike &&
+            !isWhitespaceChar(segments[segments.length - 1]?.segment || "")) {
+            newCursor -= segments.pop()?.segment.length || 0;
+        }
+    }
+    return newCursor;
+}
+/**
+ * Find the cursor position after moving one word forward from `cursor` in `text`.
+ * Skips leading whitespace, then stops at the next word/punctuation boundary.
+ *
+ * Pure function - does not mutate any state.
+ */
+export function findWordForward(text, cursor, options) {
+    if (cursor >= text.length)
+        return text.length;
+    const textAfterCursor = text.slice(cursor);
+    const segmentFn = options?.segment;
+    const isAtomic = options?.isAtomicSegment;
+    const segments = segmentFn ? segmentFn(textAfterCursor) : wordSegmenter.segment(textAfterCursor);
+    const iterator = segments[Symbol.iterator]();
+    let next = iterator.next();
+    let newCursor = cursor;
+    // Skip leading whitespace
+    while (!next.done && !isAtomic?.(next.value.segment) && isWhitespaceChar(next.value.segment)) {
+        newCursor += next.value.segment.length;
+        next = iterator.next();
+    }
+    if (next.done)
+        return newCursor;
+    if (isAtomic?.(next.value.segment)) {
+        // Skip one atomic segment.
+        newCursor += next.value.segment.length;
+    }
+    else if (next.value.isWordLike) {
+        // Skip inside one word-like segment, preserving ASCII punctuation boundaries.
+        newCursor += PUNCTUATION_REGEX.exec(next.value.segment)?.index ?? next.value.segment.length;
+    }
+    else {
+        // Skip non-word non-whitespace run (punctuation)
+        while (!next.done &&
+            !isAtomic?.(next.value.segment) &&
+            !next.value.isWordLike &&
+            !isWhitespaceChar(next.value.segment)) {
+            newCursor += next.value.segment.length;
+            next = iterator.next();
+        }
+    }
+    return newCursor;
+}

package/dist/integrations/pi/session-ui/prompt-chips.d.ts

@@ -28,5 +28,6 @@ export declare class PromptChipStore {
         target: string;
     }[];
     expandCopiedText(text: string): string;
+    prepareHistoryText(text: string): string;
     prepareSubmission(text: string): PreparedPrompt;
 }

package/dist/integrations/pi/session-ui/prompt-chips.js

@@ -171,6 +171,9 @@ export class PromptChipStore {
     expandCopiedText(text) {
         return this.#replaceResolvable(text, false).text;
     }
+    prepareHistoryText(text) {
+        return this.#replaceResolvable(text, false).text.replace(CHIP_PATTERN, tag => this.#chips.get(tag)?.kind === "image" ? "" : tag).trim();
+    }
     prepareSubmission(text) {
         const expanded = this.#replaceResolvable(text, true);
         return { text: expanded.text, images: expanded.images };

package/dist/integrations/pi/session-ui/prompt-history-controller.d.ts

@@ -0,0 +1,30 @@
+import { type PromptHistoryKind, type PromptHistoryPort } from "../../../contracts/owned-ui/index.js";
+import type { PiShellEditorPort } from "../components/index.js";
+/** Merges bounded recall snapshots; the editor alone owns browsing, draft, cursor, and undo state. */
+export declare class PromptHistoryController {
+    #private;
+    readonly options: {
+        editor: PiShellEditorPort;
+        store: PromptHistoryPort;
+        limit: number;
+        fallback: readonly string[];
+        active(): boolean;
+        render(): void;
+        failure(message: string): void;
+    };
+    constructor(options: {
+        editor: PiShellEditorPort;
+        store: PromptHistoryPort;
+        limit: number;
+        fallback: readonly string[];
+        active(): boolean;
+        render(): void;
+        failure(message: string): void;
+    });
+    start(): void;
+    capture(text: string, kind: PromptHistoryKind, cwd: string, sessionId: string): void;
+    rememberRecovery(text: string): void;
+    synchronize(): void;
+    reset(fallback: readonly string[]): void;
+    close(): Promise<boolean>;
+}

package/dist/integrations/pi/session-ui/prompt-history-controller.js

@@ -0,0 +1,147 @@
+import { randomUUID } from "node:crypto";
+import { PROMPT_HISTORY_MAX_TEXT_BYTES } from "../../../contracts/owned-ui/index.js";
+/** Merges bounded recall snapshots; the editor alone owns browsing, draft, cursor, and undo state. */
+export class PromptHistoryController {
+    options;
+    #local = new Map();
+    #unsubscribe;
+    #snapshot;
+    #fallback;
+    #disposed = false;
+    #generation = 0;
+    #unsubscribeSnapshot;
+    #unsubscribeFailure;
+    #closeFailed = false;
+    #closePromise;
+    constructor(options) {
+        this.options = options;
+        if (options.editor.recall === undefined)
+            throw new Error("The selected editor does not expose typed history");
+        this.#snapshot = { revision: 0, limit: options.limit, entries: [] };
+        this.#fallback = boundedTexts([...options.fallback].reverse(), options.limit);
+        this.#unsubscribeSnapshot = this.#subscribeSnapshot();
+        this.#unsubscribeFailure = options.store.onFailure(code => {
+            if (this.#disposed)
+                this.#closeFailed = true;
+            else
+                options.failure(`Prompt history ${code}; current-session recall remains available.`);
+        });
+        this.#unsubscribe = [
+            options.editor.recall.observe(() => {
+                if (this.#disposed)
+                    return;
+                if (options.editor.recall.position().index === -1)
+                    this.synchronize();
+                options.store.refresh();
+            }),
+        ];
+        this.synchronize();
+    }
+    start() { this.options.store.start(); }
+    capture(text, kind, cwd, sessionId) {
+        const canonical = text.trim();
+        if (!canonical || this.#disposed)
+            return;
+        const id = randomUUID();
+        const generation = this.#generation;
+        this.#local.set(id, { text: canonical, committed: false });
+        this.#boundLocal();
+        this.synchronize();
+        void this.options.store.record({ id, text: canonical, timestamp: Date.now(), kind, cwd, sessionId }).then(outcome => {
+            if (this.#disposed || generation !== this.#generation)
+                return;
+            const local = this.#local.get(id);
+            if (local === undefined || outcome !== "committed")
+                return;
+            local.committed = true;
+            if (this.#snapshot.entries.some(entry => entry.submissionId === id))
+                this.#local.delete(id);
+            this.synchronize();
+        }).catch(() => {
+            if (!this.#disposed)
+                this.options.failure("Prompt history unavailable; current-session recall remains available.");
+        });
+    }
+    rememberRecovery(text) {
+        if (this.#disposed || !text.trim())
+            return;
+        const canonical = text.trim();
+        if ([...this.#local.values()].some(item => item.text === canonical)
+            || this.#snapshot.entries.some(item => item.text === canonical))
+            return;
+        this.#local.set(randomUUID(), { text: canonical, committed: false });
+        this.#boundLocal();
+        this.synchronize();
+    }
+    synchronize() {
+        if (this.#disposed || !this.options.active())
+            return;
+        const values = [...this.#local.values()].reverse().map(item => item.text)
+            .concat(this.#snapshot.entries.map(item => item.text), this.#fallback);
+        this.options.editor.recall.replace(boundedTexts(values, this.#snapshot.limit));
+        this.options.render();
+    }
+    reset(fallback) {
+        this.#generation++;
+        this.#unsubscribeSnapshot();
+        this.#unsubscribeSnapshot = this.#subscribeSnapshot();
+        this.#fallback = boundedTexts([...fallback].reverse(), this.options.limit);
+        this.#local.clear();
+        this.options.editor.recall.reset();
+        this.synchronize();
+        this.options.store.refresh();
+    }
+    close() {
+        if (this.#closePromise !== undefined)
+            return this.#closePromise;
+        this.#disposed = true;
+        this.#unsubscribeSnapshot();
+        for (const unsubscribe of this.#unsubscribe)
+            unsubscribe();
+        this.#local.clear();
+        this.#fallback = [];
+        this.#closePromise = this.options.store.close().then(() => !this.#closeFailed, () => false)
+            .finally(() => this.#unsubscribeFailure());
+        return this.#closePromise;
+    }
+    #subscribeSnapshot() {
+        const generation = this.#generation;
+        return this.options.store.onSnapshot(snapshot => {
+            if (this.#disposed || generation !== this.#generation || snapshot.revision < this.#snapshot.revision)
+                return;
+            this.#snapshot = snapshot;
+            for (const [id, entry] of this.#local) {
+                if (entry.committed)
+                    this.#local.delete(id);
+            }
+            this.synchronize();
+        });
+    }
+    #boundLocal() {
+        let bytes = [...this.#local.values()].reduce((sum, item) => sum + Buffer.byteLength(item.text), 0);
+        while (this.#local.size > this.options.limit || bytes > PROMPT_HISTORY_MAX_TEXT_BYTES) {
+            const id = this.#local.keys().next().value;
+            bytes -= Buffer.byteLength(this.#local.get(id).text);
+            this.#local.delete(id);
+        }
+    }
+}
+function boundedTexts(values, limit) {
+    const result = [];
+    const seen = new Set();
+    let bytes = 0;
+    for (const value of values) {
+        const text = value.trim();
+        if (!text || seen.has(text))
+            continue;
+        const size = Buffer.byteLength(text);
+        if (bytes + size > PROMPT_HISTORY_MAX_TEXT_BYTES)
+            continue;
+        result.push(text);
+        seen.add(text);
+        bytes += size;
+        if (result.length >= limit)
+            break;
+    }
+    return result;
+}

package/dist/integrations/pi/session-ui/session-shell-root.d.ts

@@ -18,6 +18,11 @@ export interface OwnedUiClipboardPort {
     writeText?(text: string): Promise<void>;
 }
 export interface OwnedUiSessionShellOptions {
+    readonly promptHistory?: {
+        readonly store: import("../../../contracts/owned-ui/index.js").PromptHistoryPort;
+        readonly limit: number;
+        readonly editor: import("../components/index.js").HistoryEditorConstructor;
+    };
     readonly backend: OwnedUiBackendPort;
     readonly cwd: string;
     readonly terminal?: OwnedUiTerminalPort;
@@ -67,6 +72,8 @@ export declare class OwnedUiSessionShellRoot implements PiTuiComponentPort {
         readonly onViewportFrame?: (frame: TranscriptViewportFrame) => void;
         readonly requestHyperlinkCleanup?: () => void;
         readonly enableDockInputReuse?: boolean;
+        readonly persistentHistory?: boolean;
+        readonly historyEditor?: import("../components/index.js").HistoryEditorConstructor;
         readonly onSubmit: (text: string) => void;
         readonly onPasteRejected?: (error: unknown) => void;
         readonly onInterrupt: () => void;
@@ -91,6 +98,7 @@ export declare class OwnedUiSessionShellRoot implements PiTuiComponentPort {
     setHideThinkingBlock(hidden: boolean): void;
     setMermaidRenderingMode(mode: "off" | "final" | "streaming"): void;
     setImagePresentation(showImages: boolean, imageWidthCells: number): void;
+    prepareHistoryText(text: string): string;
     preparePromptSubmission(text: string): PreparedPrompt;
     hasPendingPastes(text: string): boolean;
     waitForPromptPastes(text: string, signal: AbortSignal): Promise<PreparedPrompt>;

package/dist/integrations/pi/session-ui/session-shell-root.js

@@ -204,6 +204,9 @@ export class OwnedUiSessionShellRoot {
             component.setImagePresentation(showImages, imageWidthCells);
         this.#invalidateTranscriptPresentation();
     }
+    prepareHistoryText(text) {
+        return this.#promptChips.prepareHistoryText(text);
+    }
     preparePromptSubmission(text) {
         return this.#promptChips.prepareSubmission(text);
     }