@timurproko/a1 0.1.8-dev.49ff83a → 0.1.8-dev.508

package/dist/integrations/pi/components/upstream/components/trust-selector.d.ts

@@ -0,0 +1,33 @@
+import { Container } from "@earendil-works/pi-tui";
+export interface TrustDecision {
+    readonly path: string;
+    readonly decision: boolean;
+}
+export interface TrustUpdate {
+    readonly path: string;
+    readonly decision: boolean | null;
+}
+export interface TrustOption {
+    readonly label: string;
+    readonly trusted: boolean;
+    readonly updates: readonly TrustUpdate[];
+    readonly savedPath?: string;
+}
+export declare class TrustSelectorComponent extends Container {
+    private selectedIndex;
+    private readonly listContainer;
+    private readonly trustOptions;
+    readonly handleInput: (data: string) => void;
+    constructor(options: {
+        readonly cwd: string;
+        readonly savedDecision: TrustDecision | null;
+        readonly projectTrusted: boolean;
+        readonly trustOptions: readonly TrustOption[];
+        readonly onSelect: (selection: {
+            readonly trusted: boolean;
+            readonly updates: readonly TrustUpdate[];
+        }) => void;
+        readonly onCancel: () => void;
+    });
+    private updateList;
+}

package/dist/integrations/pi/components/upstream/components/trust-selector.js

@@ -0,0 +1,81 @@
+/**
+ * Provenance: @earendil-works/pi-coding-agent 0.85.1 (MIT), commit d981de1229ef899957bbe968bc8dcda02a21f477,
+ * packages/coding-agent/src/modes/interactive/components/trust-selector.ts.
+ * Modifications: Mechanical source-synchronized trust selector port with injected public
+ * ProjectTrustStore-derived options and remapped owned theme imports.
+ * Deviations: none.
+ */
+import { DynamicBorder, keyHint, rawKeyHint } from "../../../startup-public.js";
+import { Container, getKeybindings, Spacer, Text } from "@earendil-works/pi-tui";
+import { piTheme } from "../theme/theme.js";
+function formatDecision(trustPath, decision) {
+    if (decision === null)
+        return "none";
+    const label = decision.decision ? "trusted" : "untrusted";
+    if (trustPath !== undefined && decision.path !== trustPath)
+        return `${label} (inherited from ${decision.path})`;
+    return `${label} (${decision.path})`;
+}
+export class TrustSelectorComponent extends Container {
+    selectedIndex;
+    listContainer;
+    trustOptions;
+    handleInput;
+    constructor(options) {
+        super();
+        this.trustOptions = options.trustOptions;
+        const isSaved = (option) => option.savedPath !== undefined
+            && options.savedDecision?.decision === option.trusted
+            && options.savedDecision.path === option.savedPath;
+        this.selectedIndex = Math.max(0, this.trustOptions.findIndex(isSaved));
+        this.addChild(new DynamicBorder());
+        this.addChild(new Spacer(1));
+        this.addChild(new Text(piTheme().fg("accent", piTheme().bold("Project trust")), 1, 0));
+        this.addChild(new Text(piTheme().fg("muted", options.cwd), 1, 0));
+        this.addChild(new Spacer(1));
+        this.addChild(new Text(piTheme().fg("muted", `Saved decision: ${formatDecision(this.trustOptions[0]?.savedPath, options.savedDecision)}`), 1, 0));
+        this.addChild(new Text(piTheme().fg("muted", `Current session: ${options.projectTrusted ? "trusted" : "untrusted"}`), 1, 0));
+        this.addChild(new Spacer(1));
+        this.listContainer = new Container();
+        this.addChild(this.listContainer);
+        this.addChild(new Spacer(1));
+        this.addChild(new Text(`${rawKeyHint("↑↓", "navigate")}  ${keyHint("tui.select.confirm", "save")}  ${keyHint("tui.select.cancel", "cancel")}`, 1, 0));
+        this.addChild(new Spacer(1));
+        this.addChild(new DynamicBorder());
+        this.updateList(options.savedDecision);
+        this.handleInput = data => {
+            const kb = getKeybindings();
+            if (kb.matches(data, "tui.select.up") || data === "k")
+                this.selectedIndex = Math.max(0, this.selectedIndex - 1);
+            else if (kb.matches(data, "tui.select.down") || data === "j")
+                this.selectedIndex = Math.min(this.trustOptions.length - 1, this.selectedIndex + 1);
+            else if (kb.matches(data, "tui.select.confirm") || data === "\n") {
+                const selected = this.trustOptions[this.selectedIndex];
+                if (selected)
+                    options.onSelect({ trusted: selected.trusted, updates: selected.updates });
+                return;
+            }
+            else if (kb.matches(data, "tui.select.cancel")) {
+                options.onCancel();
+                return;
+            }
+            else
+                return;
+            this.updateList(options.savedDecision);
+        };
+    }
+    updateList(savedDecision) {
+        this.listContainer.clear();
+        for (let index = 0; index < this.trustOptions.length; index += 1) {
+            const option = this.trustOptions[index];
+            if (!option)
+                continue;
+            const selected = index === this.selectedIndex;
+            const current = option.savedPath !== undefined && savedDecision?.decision === option.trusted && savedDecision.path === option.savedPath;
+            const prefix = selected ? piTheme().fg("accent", "→ ") : "  ";
+            const label = selected ? piTheme().fg("accent", option.label) : piTheme().fg("text", option.label);
+            const currentMarker = current ? piTheme().fg("accent", "✓ ") : "  ";
+            this.listContainer.addChild(new Text(`${prefix}${currentMarker}${label}`, 1, 0));
+        }
+    }
+}

package/dist/integrations/pi/components/upstream/external-editor.js

@@ -0,0 +1,43 @@
+/**
+ * Provenance: @earendil-works/pi-coding-agent 0.85.1 (MIT), commit d981de1229ef899957bbe968bc8dcda02a21f477,
+ * packages/coding-agent/src/modes/interactive/external-editor.ts.
+ * Modifications: Mechanical port: retain temporary prompt file, asynchronous inherited-stdio editor
+ * process, completion readback, and best-effort cleanup behind the owned extension-editor component.
+ * Deviations: none.
+ */
+import { spawn } from "node:child_process";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+export async function editInExternalEditor(options) {
+    const directory = mkdtempSync(join(tmpdir(), "pi-editor-"));
+    const filePath = join(directory, "prompt.md");
+    try {
+        writeFileSync(filePath, options.content, "utf-8");
+        const [editor, ...editorArgs] = options.command.split(" ");
+        if (!editor)
+            return { status: "failed" };
+        process.stdout.write(`Launching external editor: ${options.command}\nPi will resume when the editor exits.\n`);
+        const exitCode = await new Promise(resolve => {
+            const child = spawn(editor, [...editorArgs, filePath], {
+                stdio: "inherit",
+                shell: process.platform === "win32",
+            });
+            child.on("error", () => resolve(null));
+            child.on("close", code => resolve(code));
+        });
+        if (exitCode !== 0)
+            return { status: "failed" };
+        // Rationale: upstream strips the BOM through a private util the package does not export; the check lives here.
+        const edited = readFileSync(filePath, "utf-8");
+        return { status: "complete", content: (edited.startsWith("") ? edited.slice(1) : edited).replace(/\n$/, "") };
+    }
+    finally {
+        try {
+            rmSync(directory, { recursive: true, force: true });
+        }
+        catch {
+            // Cleanup is best effort.
+        }
+    }
+}

package/dist/integrations/pi/components/upstream/history/editor-core.d.ts

@@ -0,0 +1,289 @@
+/**
+ * Provenance: @earendil-works/pi-tui 0.85.1 (MIT), commit d981de1229ef899957bbe968bc8dcda02a21f477,
+ * packages/tui/src/components/editor.ts.
+ * Modifications: Owned editor core or minimal editor-local helper subset; public imports, strict
+ * types, typed persistent-history hooks, and semantic border state with the user-approved numeric-only
+ * history label. Public terminal runtime/exports remain shared and unchanged. See
+ * docs/architecture/history-editor-provenance.md.
+ * Deviations: compact-history-counter-label, persistent-history-owned-editor-boundary.
+ */
+import { type AutocompleteProvider, type Component, type Focusable, type TUI, type TuiMouseEvent, type TuiMouseEventResult, type SelectListTheme } from "@earendil-works/pi-tui";
+import type { EditorInteractionPort, EditorRecallPort } from "../../editor-interaction.js";
+/**
+ * Represents a chunk of text for word-wrap layout.
+ * Tracks both the text content and its position in the original line.
+ */
+export interface TextChunk {
+    text: string;
+    startIndex: number;
+    endIndex: number;
+}
+/**
+ * Split a line into word-wrapped chunks.
+ * Wraps at word boundaries when possible, falling back to character-level
+ * wrapping for words longer than the available width.
+ *
+ * @param line - The text line to wrap
+ * @param maxWidth - Maximum visible width per chunk
+ * @param preSegmented - Optional pre-segmented graphemes (e.g. with paste-marker awareness).
+ *                       When omitted the default Intl.Segmenter is used.
+ * @returns Array of chunks with text and position information
+ */
+export declare function wordWrapLine(line: string, maxWidth: number, preSegmented?: Intl.SegmentData[]): TextChunk[];
+export interface EditorTheme {
+    borderColor: (str: string) => string;
+    selectList: SelectListTheme;
+}
+export interface EditorOptions {
+    persistentHistory?: boolean;
+    styleHistoryLabel?: (text: string) => string;
+    paddingX?: number;
+    autocompleteMaxVisible?: number;
+}
+export declare class HistoryEditorCore implements Component, Focusable {
+    private segmentTransform;
+    readonly interaction: EditorInteractionPort;
+    private state;
+    /** Focusable interface - set by TUI when focus changes */
+    focused: boolean;
+    protected tui: TUI;
+    private theme;
+    private paddingX;
+    private lastWidth;
+    private renderedVisibleLineCount;
+    private renderedAutocompleteHeight;
+    private scrollOffset;
+    borderColor: (str: string) => string;
+    private autocompleteProvider?;
+    private autocompleteTriggerCharacters;
+    private autocompleteTriggerPattern;
+    private autocompleteDebouncePattern;
+    private autocompleteList;
+    private autocompleteState;
+    private autocompletePrefix;
+    private autocompleteMaxVisible;
+    private autocompleteAbort;
+    private autocompleteDebounceTimer;
+    private autocompleteRequestTask;
+    private autocompleteStartToken;
+    private autocompleteRequestId;
+    private pastes;
+    private pasteCounter;
+    private pasteBuffer;
+    private isInPaste;
+    private history;
+    private historyIndex;
+    private historyDraft;
+    readonly recall: EditorRecallPort;
+    private persistentHistory;
+    private readonly styleHistoryLabel;
+    private historyPasteDraft;
+    private pendingHistory;
+    onHistoryChange?: (state: {
+        readonly index: number;
+        readonly total: number;
+    }) => void;
+    configurePersistentHistory(enabled: boolean): void;
+    replaceHistoryEntries(entries: readonly string[]): void;
+    getHistoryPosition(): {
+        readonly index: number;
+        readonly total: number;
+    };
+    resetHistoryBrowsing(): void;
+    private applyPendingHistory;
+    private notifyHistory;
+    private killRing;
+    private lastAction;
+    private jumpMode;
+    private preferredVisualCol;
+    private snappedFromCursorCol;
+    private undoStack;
+    onSubmit?: (text: string) => void;
+    onChange?: (text: string) => void;
+    disableSubmit: boolean;
+    constructor(tui: TUI, theme: EditorTheme, options?: EditorOptions);
+    /** Set of currently valid paste IDs, for marker-aware segmentation. */
+    private validPasteIds;
+    /** Segment text with paste-marker awareness, only merging markers with valid IDs. */
+    private segment;
+    getPaddingX(): number;
+    setPaddingX(padding: number): void;
+    getAutocompleteMaxVisible(): number;
+    setAutocompleteMaxVisible(maxVisible: number): void;
+    setAutocompleteProvider(provider: AutocompleteProvider): void;
+    /**
+     * Add a prompt to history for up/down arrow navigation.
+     * Called after successful submission.
+     */
+    addToHistory(text: string): void;
+    private isEditorEmpty;
+    private isOnFirstVisualLine;
+    private isOnLastVisualLine;
+    private navigateHistory;
+    private exitHistoryBrowsing;
+    /** Internal setText that doesn't reset history state - used by navigateHistory */
+    private setTextInternal;
+    invalidate(): void;
+    protected renderTopBorder(width: number, hiddenLineCount: number): string;
+    protected renderBottomBorder(width: number, hiddenLineCount: number): string;
+    render(width: number): string[];
+    handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined;
+    handleInput(data: string): void;
+    private layoutText;
+    getText(): string;
+    private expandPasteMarkers;
+    /**
+     * Get text with paste markers expanded to their actual content.
+     * Use this when you need the full content (e.g., for external editor).
+     */
+    getExpandedText(): string;
+    getLines(): string[];
+    getCursor(): {
+        line: number;
+        col: number;
+    };
+    setText(text: string): void;
+    /**
+     * Insert text at the current cursor position.
+     * Used for programmatic insertion (e.g., clipboard image markers).
+     * This is atomic for undo - single undo restores entire pre-insert state.
+     */
+    insertTextAtCursor(text: string): void;
+    /**
+     * Normalize text for editor storage:
+     * - Normalize line endings (\r\n and \r -> \n)
+     * - Expand tabs to 4 spaces
+     */
+    private normalizeText;
+    /**
+     * Internal text insertion at cursor. Handles single and multi-line text.
+     * Does not push undo snapshots or trigger autocomplete - caller is responsible.
+     * Normalizes line endings and calls onChange once at the end.
+     */
+    private insertTextAtCursorInternal;
+    private insertCharacter;
+    private handlePaste;
+    private addNewLine;
+    private shouldSubmitOnBackslashEnter;
+    private submitValue;
+    private handleBackspace;
+    /**
+     * Set cursor column and clear preferredVisualCol.
+     * Use this for all non-vertical cursor movements to reset sticky column behavior.
+     */
+    private setCursorCol;
+    /**
+     * Move cursor to a target visual line, applying sticky column logic.
+     * Shared by moveCursor() and pageScroll().
+     */
+    private moveToVisualLine;
+    /**
+     * Compute the target visual column for vertical cursor movement.
+     * Implements the sticky column decision table:
+     *
+     * | P | S | T | U | Scenario                                             | Set Preferred | Move To     |
+     * |---|---|---|---| ---------------------------------------------------- |---------------|-------------|
+     * | 0 | * | 0 | - | Start nav, target fits                               | null          | current     |
+     * | 0 | * | 1 | - | Start nav, target shorter                            | current       | target end  |
+     * | 1 | 0 | 0 | 0 | Clamped, target fits preferred                       | null          | preferred   |
+     * | 1 | 0 | 0 | 1 | Clamped, target longer but still can't fit preferred | keep          | target end  |
+     * | 1 | 0 | 1 | - | Clamped, target even shorter                         | keep          | target end  |
+     * | 1 | 1 | 0 | - | Rewrapped, target fits current                       | null          | current     |
+     * | 1 | 1 | 1 | - | Rewrapped, target shorter than current               | current       | target end  |
+     *
+     * Where:
+     * - P = preferred col is set
+     * - S = cursor in middle of source line (not clamped to end)
+     * - T = target line shorter than current visual col
+     * - U = target line shorter than preferred col
+     */
+    private computeVerticalMoveColumn;
+    private moveToLineStart;
+    private moveToLineEnd;
+    private deleteToStartOfLine;
+    private deleteToEndOfLine;
+    private deleteWordBackwards;
+    private deleteWordForward;
+    private handleForwardDelete;
+    /**
+     * Build a mapping from visual lines to logical positions.
+     * Returns an array where each element represents a visual line with:
+     * - logicalLine: index into this.state.lines
+     * - startCol: starting column in the logical line
+     * - length: length of this visual line segment
+     */
+    private buildVisualLineMap;
+    /**
+     * Find the visual line index that contains the given logical position.
+     */
+    private findVisualLineAt;
+    /**
+     * Find the visual line index for the current cursor position.
+     */
+    private findCurrentVisualLine;
+    private moveCursor;
+    /**
+     * Scroll by a page (direction: -1 for up, 1 for down).
+     * Moves cursor by the page size while keeping it in bounds.
+     */
+    private pageScroll;
+    private moveWordBackwards;
+    /**
+     * Yank (paste) the most recent kill ring entry at cursor position.
+     */
+    private yank;
+    /**
+     * Cycle through kill ring (only works immediately after yank or yank-pop).
+     * Replaces the last yanked text with the previous entry in the ring.
+     */
+    private yankPop;
+    /**
+     * Insert text at cursor position (used by yank operations).
+     */
+    private insertYankedText;
+    /**
+     * Delete the previously yanked text (used by yank-pop).
+     * The yanked text is derived from killRing[end] since it hasn't been rotated yet.
+     */
+    private deleteYankedText;
+    private pushUndoSnapshot;
+    private undo;
+    /**
+     * Jump to the first occurrence of a character in the specified direction.
+     * Multi-line search. Case-sensitive. Skips the current cursor position.
+     */
+    private jumpToChar;
+    private moveWordForwards;
+    private isSlashMenuAllowed;
+    private isAtStartOfMessage;
+    private isInSlashCommandContext;
+    /**
+     * Find the best autocomplete item index for the given prefix.
+     * Returns -1 if no match is found.
+     *
+     * Match priority:
+     * 1. Exact match (prefix === item.value) -> always selected
+     * 2. Prefix match -> first item whose value starts with prefix
+     * 3. No match -> -1 (keep default highlight)
+     *
+     * Matching is case-sensitive and checks item.value only.
+     */
+    private getBestAutocompleteMatchIndex;
+    private createAutocompleteList;
+    private tryTriggerAutocomplete;
+    private handleTabCompletion;
+    private handleSlashCommandCompletion;
+    private forceFileAutocomplete;
+    private requestAutocomplete;
+    private startAutocompleteRequest;
+    private setAutocompleteTriggerCharacters;
+    private getAutocompleteDebounceMs;
+    private runAutocompleteRequest;
+    private isAutocompleteRequestCurrent;
+    private applyAutocompleteSuggestions;
+    private cancelAutocompleteRequest;
+    private clearAutocompleteUi;
+    private cancelAutocomplete;
+    isShowingAutocomplete(): boolean;
+    private updateAutocomplete;
+}