@timurproko/a1 0.1.8-dev.ece8cef → 0.2.0

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

@@ -0,0 +1,365 @@
+/**
+ * Provenance: @earendil-works/pi-coding-agent 0.87.1 (MIT), commit f07218c4d4bbc12bef056a7058c3dd49dfe41abe,
+ * packages/coding-agent/src/modes/interactive/components/tool-execution.ts.
+ * Modifications: Retain pinned shell and actual public tool-definition renderers. Replace private
+ * index-keyed image conversion with current-source ownership, serial conversion, visible fallback, and
+ * disposal; guard reentrant invalidation. Remap private types, definition factories, theme, and
+ * generic text helpers to public or locally attributed equivalents. See
+ * docs/architecture/tool-image-presentation.md.
+ * Deviations: current-tool-image-conversion-ownership.
+ */
+import { stripVTControlCharacters } from "node:util";
+import { Box, Container, getCapabilities, getImageDimensions, imageFallback, MouseRegion, Spacer, Text } from "@earendil-works/pi-tui";
+import { createReadToolDefinition, createBashToolDefinition, createEditToolDefinition, createWriteToolDefinition, createGrepToolDefinition, createFindToolDefinition, createLsToolDefinition, keyHint, } from "../../../startup-public.js";
+import { piTheme } from "../theme/theme.js";
+import { ToolImagePresentation } from "../../tool-image-presentation.js";
+/** The caller-side merge 0.85.1 performs before handing a definition to the component: built-in renderers fill the gaps. */
+export function mergeBuiltInRenderers(definition, builtIn) {
+    if (definition === undefined)
+        return builtIn;
+    if (builtIn === undefined)
+        return definition;
+    const merged = { ...definition };
+    if (definition.renderCall === undefined && builtIn.renderCall !== undefined)
+        merged.renderCall = builtIn.renderCall;
+    if (definition.renderResult === undefined && builtIn.renderResult !== undefined)
+        merged.renderResult = builtIn.renderResult;
+    return merged;
+}
+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;
+    contentTextRegion;
+    selfRenderContainer;
+    selfRenderHeight = 0;
+    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.builtInToolDefinition = Object.hasOwn(definitions, toolName)
+            ? definitions[toolName](cwd) : undefined;
+        // Rationale: 0.85.1 moved the built-in renderer fallback to the caller; A1 keeps it here so every caller of
+        // the owned component gets the built-in edit/read/bash renderers without reaching into the tool registry.
+        this.toolDefinition = mergeBuiltInRenderers(toolDefinition, this.builtInToolDefinition);
+        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.contentTextRegion = this.createResultRegion(this.contentText);
+        this.selfRenderContainer = new Container();
+        if (this.hasRendererDefinition()) {
+            this.addChild(this.getRenderShell() === "self" ? this.selfRenderContainer : this.contentBox);
+        }
+        else {
+            this.addChild(this.contentTextRegion);
+        }
+        this.updateDisplay();
+    }
+    getCallRenderer() {
+        return this.toolDefinition?.renderCall;
+    }
+    getResultRenderer() {
+        return this.toolDefinition?.renderResult;
+    }
+    hasRendererDefinition() {
+        return this.toolDefinition !== undefined;
+    }
+    getRenderShell() {
+        return this.toolDefinition?.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);
+    }
+    createResultRegion(component) {
+        return new MouseRegion(component, (event) => {
+            if (!this.result || event.type !== "click" || event.button !== "left")
+                return undefined;
+            this.setExpanded(!this.expanded);
+            return { handled: true };
+        });
+    }
+    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);
+            this.selfRenderHeight = contentLines.length;
+            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);
+    }
+    handleMouse(event) {
+        if (!this.hasRendererDefinition() || this.getRenderShell() !== "self")
+            return super.handleMouse(event);
+        if (event.y <= 0 || event.y > this.selfRenderHeight)
+            return undefined;
+        return this.selfRenderContainer.handleMouse({
+            ...event,
+            y: event.y - 1,
+            height: this.selfRenderHeight,
+        });
+    }
+    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.createResultRegion(this.createCallFallback()));
+                hasContent = true;
+            }
+            else {
+                try {
+                    const component = callRenderer(this.args, theme, this.getRenderContext(this.callRendererComponent));
+                    this.callRendererComponent = component;
+                    renderContainer.addChild(this.createResultRegion(component));
+                    hasContent = true;
+                }
+                catch {
+                    this.callRendererComponent = undefined;
+                    renderContainer.addChild(this.createResultRegion(this.createCallFallback()));
+                    hasContent = true;
+                }
+            }
+            if (this.result) {
+                const resultRenderer = this.getResultRenderer();
+                if (!resultRenderer) {
+                    const component = this.createResultFallback();
+                    if (component) {
+                        renderContainer.addChild(this.createResultRegion(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(this.createResultRegion(component));
+                        hasContent = true;
+                    }
+                    catch {
+                        this.resultRendererComponent = undefined;
+                        const component = this.createResultFallback();
+                        if (component) {
+                            renderContainer.addChild(this.createResultRegion(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/components/tree-selector.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Provenance: @earendil-works/pi-coding-agent 0.87.1 (MIT), commit f07218c4d4bbc12bef056a7058c3dd49dfe41abe,
+ * packages/coding-agent/src/modes/interactive/components/tree-selector.ts.
+ * Modifications: Source-synchronized tree selector port: preserve filtering, folding, labels, copying,
+ * tree navigation, key hints, focus, and viewport behavior while remapping public types/components
+ * plus owned keybindings/theme helpers required to avoid the pinned package nested pi-tui singleton;
+ * bare A1 uses the shared semantic modal shortcut row and compact padded modal frame.
+ * Deviations: owned-modal-shortcut-hints.
+ */
+import { type Component, Container, type Focusable } from "@earendil-works/pi-tui";
+import { type SessionTreeNode } from "@earendil-works/pi-coding-agent";
+/** Filter mode for tree display */
+export type FilterMode = "default" | "no-tools" | "user-only" | "labeled-only" | "all";
+declare class TreeList implements Component {
+    private flatNodes;
+    private filteredNodes;
+    private selectedIndex;
+    private currentLeafId;
+    private maxVisibleLines;
+    private filterMode;
+    private searchQuery;
+    private toolCallMap;
+    private multipleRoots;
+    private showLabelTimestamps;
+    private activePathIds;
+    private visibleParentMap;
+    private visibleChildrenMap;
+    private lastSelectedId;
+    private foldedNodes;
+    onSelect?: (entryId: string) => void;
+    onCancel?: () => void;
+    onCopy?: (text: string | undefined) => void;
+    onLabelEdit?: (entryId: string, currentLabel: string | undefined) => void;
+    constructor(tree: SessionTreeNode[], currentLeafId: string | null, maxVisibleLines: number, initialSelectedId?: string, initialFilterMode?: FilterMode);
+    /**
+     * Find the index of the nearest visible entry, walking up the parent chain if needed.
+     * Returns the index in filteredNodes, or the last index as fallback.
+     */
+    private findNearestVisibleIndex;
+    /** Build the set of entry IDs on the path from root to current leaf */
+    private buildActivePath;
+    private flattenTree;
+    private applyFilter;
+    /**
+     * Recompute indentation/connectors for the filtered view
+     *
+     * Filtering can hide intermediate entries; descendants attach to the nearest visible ancestor.
+     * Keep indentation semantics aligned with flattenTree() so single-child chains don't drift right.
+     */
+    private recalculateVisualStructure;
+    /** Get searchable text content from a node */
+    private getSearchableText;
+    invalidate(): void;
+    getSearchQuery(): string;
+    getSelectedNode(): SessionTreeNode | undefined;
+    copySelected(): void;
+    updateNodeLabel(entryId: string, label: string | undefined, labelTimestamp?: string): void;
+    private getStatusLabels;
+    render(width: number): string[];
+    private getEntryDisplayText;
+    private formatLabelTimestamp;
+    private extractContent;
+    private extractFullContent;
+    private getEntryCopyText;
+    private hasTextContent;
+    private formatToolCall;
+    handleInput(keyData: string): void;
+    /**
+     * Whether a node can be folded. A node is foldable if it has visible children
+     * and is either a root (no visible parent) or a segment start (visible parent
+     * has multiple visible children).
+     */
+    private isFoldable;
+    /**
+     * Find the index of the next branch segment start in the given direction.
+     * A segment start is the first child of a branch point.
+     *
+     * "up" walks the visible parent chain; "down" walks visible children
+     * (always following the first child).
+     */
+    private findBranchSegmentStart;
+}
+/**
+ * Component that renders a session tree selector for navigation
+ */
+export declare class TreeSelectorComponent extends Container implements Focusable {
+    private treeList;
+    private labelInput;
+    private labelInputContainer;
+    private treeContainer;
+    private onLabelChangeCallback;
+    onCopy?: (text: string | undefined) => void;
+    private _focused;
+    get focused(): boolean;
+    set focused(value: boolean);
+    constructor(tree: SessionTreeNode[], currentLeafId: string | null, terminalHeight: number, onSelect: (entryId: string) => void, onCancel: () => void, onLabelChange?: (entryId: string, label: string | undefined) => void, initialSelectedId?: string, initialFilterMode?: FilterMode);
+    private showLabelInput;
+    private hideLabelInput;
+    handleInput(keyData: string): void;
+    getTreeList(): TreeList;
+}
+export {};