@timurproko/a1 0.1.8-dev.3b54f21 → 0.1.8-dev.407

package/dist/integrations/pi/components/upstream/components/tool-execution.js

@@ -0,0 +1,344 @@
+/**
+ * Source-derived from Pi 0.84.2, MIT, repository https://github.com/earendil-works/pi,
+ * commit 914cf1472e715297caa30db4b9535d534a9eb718:
+ * packages/coding-agent/src/modes/interactive/components/tool-execution.ts.
+ * The private image cache cannot be corrected through the public component API without
+ * rebuilding renderer state. Retain its shell/lifecycle and actual public tool definitions;
+ * replace only image ownership/conversion, guard invalidation, and remap private imports.
+ * Generic text fallback below follows core/tools/render-utils.ts and utils/shell.ts.
+ */
+import { stripVTControlCharacters } from "node:util";
+import { Box, Container, getCapabilities, getImageDimensions, imageFallback, Spacer, Text } from "#pi-tui";
+import { createReadToolDefinition, createBashToolDefinition, createEditToolDefinition, createWriteToolDefinition, createGrepToolDefinition, createFindToolDefinition, createLsToolDefinition, keyHint, } from "@earendil-works/pi-coding-agent";
+import { piTheme } from "../theme/theme.js";
+import { ToolImagePresentation } from "../../tool-image-presentation.js";
+const definitions = { read: createReadToolDefinition, bash: createBashToolDefinition, edit: createEditToolDefinition,
+    write: createWriteToolDefinition, grep: createGrepToolDefinition, find: createFindToolDefinition, ls: createLsToolDefinition };
+const FALLBACK_PREVIEW_LINES = 10;
+export class ToolExecutionComponent extends Container {
+    contentBox;
+    contentText;
+    selfRenderContainer;
+    callRendererComponent;
+    resultRendererComponent;
+    rendererState = {};
+    imageComponents = [];
+    images;
+    disposed = false;
+    updatingDisplay = false;
+    imageSpacers = [];
+    toolName;
+    toolCallId;
+    args;
+    expanded = false;
+    showImages;
+    imageWidthCells;
+    isPartial = true;
+    toolDefinition;
+    builtInToolDefinition;
+    ui;
+    cwd;
+    executionStarted = false;
+    argsComplete = false;
+    result;
+    hideComponent = false;
+    constructor(toolName, toolCallId, args, options = {}, toolDefinition, ui, cwd) {
+        super();
+        this.toolName = toolName;
+        this.toolCallId = toolCallId;
+        this.args = args;
+        this.toolDefinition = toolDefinition;
+        this.builtInToolDefinition = Object.hasOwn(definitions, toolName)
+            ? definitions[toolName](cwd) : undefined;
+        this.showImages = options.showImages ?? true;
+        this.imageWidthCells = options.imageWidthCells ?? 60;
+        this.ui = ui;
+        this.cwd = cwd;
+        this.images = new ToolImagePresentation(() => {
+            if (this.disposed)
+                return;
+            this.updateDisplay();
+            this.ui.requestRender();
+        });
+        this.addChild(new Spacer(1));
+        // Always create all shell variants. contentBox is used for default renderer-based composition.
+        // selfRenderContainer is used when the tool renders its own framing.
+        // contentText is reserved for generic fallback rendering when no tool definition exists.
+        this.contentBox = new Box(1, 1, (text) => piTheme().bg("toolPendingBg", text));
+        this.contentText = new Text("", 1, 1, (text) => piTheme().bg("toolPendingBg", text));
+        this.selfRenderContainer = new Container();
+        if (this.hasRendererDefinition()) {
+            this.addChild(this.getRenderShell() === "self" ? this.selfRenderContainer : this.contentBox);
+        }
+        else {
+            this.addChild(this.contentText);
+        }
+        this.updateDisplay();
+    }
+    getCallRenderer() {
+        if (!this.builtInToolDefinition) {
+            return this.toolDefinition?.renderCall;
+        }
+        if (!this.toolDefinition) {
+            return this.builtInToolDefinition.renderCall;
+        }
+        return this.toolDefinition.renderCall ?? this.builtInToolDefinition.renderCall;
+    }
+    getResultRenderer() {
+        if (!this.builtInToolDefinition) {
+            return this.toolDefinition?.renderResult;
+        }
+        if (!this.toolDefinition) {
+            return this.builtInToolDefinition.renderResult;
+        }
+        return this.toolDefinition.renderResult ?? this.builtInToolDefinition.renderResult;
+    }
+    hasRendererDefinition() {
+        return this.builtInToolDefinition !== undefined || this.toolDefinition !== undefined;
+    }
+    getRenderShell() {
+        if (!this.builtInToolDefinition) {
+            return this.toolDefinition?.renderShell ?? "default";
+        }
+        if (!this.toolDefinition) {
+            return this.builtInToolDefinition.renderShell ?? "default";
+        }
+        return this.toolDefinition.renderShell ?? this.builtInToolDefinition.renderShell ?? "default";
+    }
+    getRenderContext(lastComponent) {
+        return {
+            args: this.args,
+            toolCallId: this.toolCallId,
+            invalidate: () => {
+                if (this.disposed || this.updatingDisplay)
+                    return;
+                this.invalidate();
+                this.ui.requestRender();
+            },
+            lastComponent,
+            state: this.rendererState,
+            cwd: this.cwd,
+            executionStarted: this.executionStarted,
+            argsComplete: this.argsComplete,
+            isPartial: this.isPartial,
+            expanded: this.expanded,
+            showImages: this.showImages,
+            isError: this.result?.isError ?? false,
+        };
+    }
+    createCallFallback() {
+        const theme = piTheme();
+        return new Text(theme.fg("toolTitle", theme.bold(this.toolName)), 0, 0);
+    }
+    createResultFallback() {
+        const theme = piTheme();
+        const output = this.getTextOutput();
+        if (!output) {
+            return undefined;
+        }
+        const lines = output.split("\n");
+        const displayLines = this.expanded ? lines : lines.slice(0, FALLBACK_PREVIEW_LINES);
+        const remaining = lines.length - displayLines.length;
+        let text = displayLines.map((line) => theme.fg("toolOutput", line)).join("\n");
+        if (remaining > 0) {
+            text += `${theme.fg("muted", `\n... (${remaining} more lines,`)} ${keyHint("app.tools.expand", "to expand")}${theme.fg("muted", ")")}`;
+        }
+        return new Text(text, 0, 0);
+    }
+    updateArgs(args) {
+        this.args = args;
+        this.updateDisplay();
+    }
+    markExecutionStarted() {
+        this.executionStarted = true;
+        this.updateDisplay();
+        this.ui.requestRender();
+    }
+    setArgsComplete() {
+        this.argsComplete = true;
+        this.updateDisplay();
+        this.ui.requestRender();
+    }
+    updateResult(result, isPartial = false) {
+        this.result = result;
+        this.isPartial = isPartial;
+        this.updateDisplay();
+    }
+    /** End mount ownership without letting an obsolete conversion or extension callback repaint. */
+    dispose() {
+        this.disposed = true;
+        this.images.dispose();
+        this.result = undefined;
+        this.callRendererComponent = undefined;
+        this.resultRendererComponent = undefined;
+        this.rendererState = {};
+        this.imageComponents = [];
+        this.imageSpacers = [];
+        this.clear();
+    }
+    setExpanded(expanded) {
+        this.expanded = expanded;
+        this.updateDisplay();
+    }
+    setShowImages(show) {
+        this.showImages = show;
+        this.updateDisplay();
+    }
+    setImageWidthCells(width) {
+        this.imageWidthCells = Math.max(1, Math.floor(width));
+        this.updateDisplay();
+    }
+    invalidate() {
+        super.invalidate();
+        this.updateDisplay();
+    }
+    render(width) {
+        if (this.hideComponent) {
+            return [];
+        }
+        if (this.hasRendererDefinition() && this.getRenderShell() === "self") {
+            const contentLines = this.selfRenderContainer.render(width);
+            if (contentLines.length === 0 && this.imageComponents.length === 0) {
+                return [];
+            }
+            const lines = [];
+            if (contentLines.length > 0) {
+                lines.push("");
+                lines.push(...contentLines);
+            }
+            for (let i = 0; i < this.imageComponents.length; i++) {
+                const spacer = this.imageSpacers[i];
+                if (spacer) {
+                    lines.push(...spacer.render(width));
+                }
+                const imageComponent = this.imageComponents[i];
+                if (imageComponent) {
+                    lines.push(...imageComponent.render(width));
+                }
+            }
+            return lines;
+        }
+        return super.render(width);
+    }
+    updateDisplay() {
+        if (this.disposed || this.updatingDisplay)
+            return;
+        this.updatingDisplay = true;
+        try {
+            this.composeDisplay();
+        }
+        finally {
+            this.updatingDisplay = false;
+        }
+    }
+    composeDisplay() {
+        const theme = piTheme();
+        const bgFn = this.isPartial
+            ? (text) => theme.bg("toolPendingBg", text)
+            : this.result?.isError
+                ? (text) => theme.bg("toolErrorBg", text)
+                : (text) => theme.bg("toolSuccessBg", text);
+        let hasContent = false;
+        this.hideComponent = false;
+        if (this.hasRendererDefinition()) {
+            const renderContainer = this.getRenderShell() === "self" ? this.selfRenderContainer : this.contentBox;
+            if (renderContainer instanceof Box) {
+                renderContainer.setBgFn(bgFn);
+            }
+            renderContainer.clear();
+            const callRenderer = this.getCallRenderer();
+            if (!callRenderer) {
+                renderContainer.addChild(this.createCallFallback());
+                hasContent = true;
+            }
+            else {
+                try {
+                    const component = callRenderer(this.args, theme, this.getRenderContext(this.callRendererComponent));
+                    this.callRendererComponent = component;
+                    renderContainer.addChild(component);
+                    hasContent = true;
+                }
+                catch {
+                    this.callRendererComponent = undefined;
+                    renderContainer.addChild(this.createCallFallback());
+                    hasContent = true;
+                }
+            }
+            if (this.result) {
+                const resultRenderer = this.getResultRenderer();
+                if (!resultRenderer) {
+                    const component = this.createResultFallback();
+                    if (component) {
+                        renderContainer.addChild(component);
+                        hasContent = true;
+                    }
+                }
+                else {
+                    try {
+                        const component = resultRenderer({ content: this.result.content, details: this.result.details }, { expanded: this.expanded, isPartial: this.isPartial }, theme, this.getRenderContext(this.resultRendererComponent));
+                        this.resultRendererComponent = component;
+                        renderContainer.addChild(component);
+                        hasContent = true;
+                    }
+                    catch {
+                        this.resultRendererComponent = undefined;
+                        const component = this.createResultFallback();
+                        if (component) {
+                            renderContainer.addChild(component);
+                            hasContent = true;
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            this.contentText.setCustomBgFn(bgFn);
+            this.contentText.setText(this.formatToolExecution());
+            hasContent = true;
+        }
+        for (const img of this.imageComponents) {
+            this.removeChild(img);
+        }
+        this.imageComponents = [];
+        for (const spacer of this.imageSpacers) {
+            this.removeChild(spacer);
+        }
+        this.imageSpacers = [];
+        this.images.update(this.result?.content ?? [], this.showImages);
+        for (const imageComponent of this.images.components(this.imageWidthCells)) {
+            const spacer = new Spacer(1);
+            this.addChild(spacer);
+            this.imageSpacers.push(spacer);
+            this.imageComponents.push(imageComponent);
+            this.addChild(imageComponent);
+        }
+        if (this.hasRendererDefinition() && !hasContent && this.imageComponents.length === 0) {
+            this.hideComponent = true;
+        }
+    }
+    getTextOutput() {
+        if (!this.result)
+            return "";
+        const text = this.result.content.filter(part => part.type === "text").map(part => Array.from(stripVTControlCharacters(part.text ?? "")).filter(char => {
+            const code = char.codePointAt(0);
+            return code === 9 || code === 10 || code > 31 && (code < 0xfff9 || code > 0xfffb);
+        }).join("")).join("\n");
+        if (getCapabilities().images && this.showImages)
+            return text;
+        const indicators = this.result.content.filter(part => part.type === "image").map(part => imageFallback(part.mimeType ?? "image/unknown", part.data && part.mimeType ? getImageDimensions(part.data, part.mimeType) ?? undefined : undefined)).join("\n");
+        return text && indicators ? `${text}\n${indicators}` : text || indicators;
+    }
+    formatToolExecution() {
+        const theme = piTheme();
+        let text = theme.fg("toolTitle", theme.bold(this.toolName));
+        const content = JSON.stringify(this.args, null, 2);
+        if (content) {
+            text += `\n\n${content}`;
+        }
+        const output = this.getTextOutput();
+        if (output) {
+            text += `\n${output}`;
+        }
+        return text;
+    }
+}

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

@@ -0,0 +1,280 @@
+/**
+ * Adapted from @earendil-works/pi-tui 0.84.2, packages/tui/src/components/editor.ts (MIT).
+ * Source commit: 914cf1472e715297caa30db4b9535d534a9eb718.
+ * Modifications: public imports and owned editor-local typed seams; see docs/architecture/history-editor-provenance.md.
+ */
+import { type AutocompleteProvider, type Component, type Focusable, type TUI, type SelectListTheme } from "#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 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;
+    render(width: number): string[];
+    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;
+}