@timurproko/a1 0.1.8-dev.368 → 0.1.8-dev.402

package/dist/integrations/pi/components/tool-image-presentation.js

@@ -0,0 +1,86 @@
+import { convertToPng } from "@earendil-works/pi-coding-agent";
+import { getCapabilities, Image, Text } from "#pi-tui";
+import { piTheme } from "./theme.js";
+const MAX_BYTES = 20 * 1024 * 1024;
+const MAX_IMAGES = 16;
+const bytes = (data) => Math.floor(data.length * 3 / 4) - (data.endsWith("==") ? 2 : data.endsWith("=") ? 1 : 0);
+/**
+ * Own only current attachment presentation; tool renderers still receive original result content.
+ * Unlike pinned 0.84.2's index cache, entries follow immutable source bytes and stale completions
+ * cannot republish. At most one conversion runs per mount; queued work is only the current set.
+ */
+export class ToolImagePresentation {
+    changed;
+    convert;
+    #entries = [];
+    #visible = false;
+    #disposed = false;
+    #active = false;
+    constructor(changed, convert = convertToPng) {
+        this.changed = changed;
+        this.convert = convert;
+    }
+    update(content, show) {
+        if (this.#disposed)
+            return;
+        const previous = this.#entries;
+        const next = [];
+        for (const part of content) {
+            if (part.type !== "image" || !part.data || !part.mimeType)
+                continue;
+            const source = { data: part.data, mimeType: part.mimeType };
+            const same = (entry) => entry.source.data === source.data && entry.source.mimeType === source.mimeType;
+            next.push(next.find(same) ?? previous.find(same) ?? { source, state: "waiting" });
+            if (next.length === MAX_IMAGES)
+                break;
+        }
+        this.#entries = next;
+        this.#visible = show && getCapabilities().images !== null;
+        this.#pump();
+    }
+    /** Public Image remains responsible for Kitty/iTerm protocol and dimension-aware fallback. */
+    components(width) {
+        if (this.#disposed || !this.#visible)
+            return [];
+        return this.#entries.map(entry => {
+            const source = entry.source;
+            if (getCapabilities().images === "kitty" && source.mimeType !== "image/png") {
+                if (entry.converted === undefined)
+                    return new Text(piTheme().fg("muted", entry.state === "unavailable" ? `[Image unavailable: ${source.mimeType}]` : `[Image converting: ${source.mimeType}]`), 1, 0);
+            }
+            const image = getCapabilities().images === "kitty" ? entry.converted ?? source : source;
+            return new Image(image.data, image.mimeType, { fallbackColor: text => piTheme().fg("toolOutput", text) }, { maxWidthCells: width });
+        });
+    }
+    dispose() {
+        this.#disposed = true;
+        this.#entries = [];
+    }
+    #pump() {
+        if (this.#disposed || this.#active || !this.#visible || getCapabilities().images !== "kitty")
+            return;
+        const entry = this.#entries.find(value => value.source.mimeType !== "image/png" && value.state === "waiting");
+        if (entry === undefined)
+            return;
+        entry.state = "converting";
+        this.#active = true;
+        // Concurrency: defer codec entry until the caller's synchronous component mutation finishes.
+        void Promise.resolve().then(() => this.#disposed || !this.#entries.includes(entry)
+            ? null : this.convert(entry.source.data, entry.source.mimeType)).catch(() => null).then(converted => {
+            this.#active = false;
+            if (this.#disposed)
+                return;
+            if (this.#entries.includes(entry)) {
+                // Invariant: limits match the existing 16 references / 20 MiB per image, not a new aggregate cap.
+                if (converted !== null && converted.mimeType === "image/png" && bytes(converted.data) <= MAX_BYTES) {
+                    entry.converted = converted;
+                    entry.state = "ready";
+                }
+                else
+                    entry.state = "unavailable";
+                this.changed();
+            }
+            this.#pump();
+        });
+    }
+}

package/dist/integrations/pi/components/tool-result-adapter.d.ts

@@ -1,6 +1,6 @@
-import type { ToolExecutionComponent } from "@earendil-works/pi-coding-agent";
+import type { ToolExecutionComponent } from "./upstream/components/tool-execution.js";
 import type { OwnedUiTranscriptBlock } from "../../../contracts/owned-ui/index.js";
 import { type PiShellImageAssetResolver } from "./shell-shared-facade.js";
 /** Reconstruct public Pi inputs once at the component boundary, never from diagnostic summaries. */
-export declare function updatePiToolResult(component: ToolExecutionComponent, block: OwnedUiTranscriptBlock, assets?: PiShellImageAssetResolver): void;
+export declare function updatePiToolResult(component: Pick<ToolExecutionComponent, "updateResult">, block: OwnedUiTranscriptBlock, assets?: PiShellImageAssetResolver): void;
 export declare function piToolArguments(block: OwnedUiTranscriptBlock): unknown;

package/dist/integrations/pi/components/transcript-image-resolver.d.ts

@@ -0,0 +1,7 @@
+import type { OwnedUiImageAttachment, OwnedUiTranscriptBlock } from "../../../contracts/owned-ui/index.js";
+import type { PiShellImageAssetResolver } from "./shell-shared-facade.js";
+export declare function createTranscriptImageResolver(source: PiShellImageAssetResolver | undefined, initial: OwnedUiTranscriptBlock): {
+    resolve: (id: string) => OwnedUiImageAttachment | null;
+    update: (block: OwnedUiTranscriptBlock) => void;
+    dispose: () => void;
+};

package/dist/integrations/pi/components/transcript-image-resolver.js

@@ -0,0 +1,19 @@
+// Concurrency: a mounted block can outlive its engine revision while delivery is pending; retain its immutable assets through rebuilds.
+export function createTranscriptImageResolver(source, initial) {
+    let images = new Map();
+    const update = (block) => {
+        const next = new Map();
+        for (const reference of block.imageReferences ?? []) {
+            const asset = source?.resolve(reference.assetId) ?? images.get(reference.assetId);
+            if (asset != null)
+                next.set(reference.assetId, asset);
+        }
+        images = next;
+    };
+    update(initial);
+    return {
+        resolve: (id) => images.get(id) ?? null,
+        update,
+        dispose: () => images.clear(),
+    };
+}

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

@@ -1,7 +1,7 @@
 /**
  * Source-synchronized from Pi 0.84.2
  * packages/coding-agent/src/modes/interactive/components/scoped-models-selector.ts
- * Mechanical changes: public DynamicBorder/keyText imports and owned theme adapter.
+ * Mechanical changes: public DynamicBorder import, local platform-aware key labels, and owned theme adapter.
  */
 interface ScopedModel {
     readonly provider: string;

package/dist/integrations/pi/components/upstream/components/scoped-models-selector.js

@@ -3,7 +3,9 @@ import { DynamicBorder } from "@earendil-works/pi-coding-agent";
 import { getModelSearchText } from "../model-search.js";
 import { piTheme } from "../theme/theme.js";
 function keyText(keybinding) {
-    return getKeybindings().getKeys(keybinding).join("/");
+    return getKeybindings().getKeys(keybinding)
+        .map((key) => key.split("+").map((part) => process.platform === "darwin" && part.toLowerCase() === "alt" ? "option" : part).join("+"))
+        .join("/");
 }
 const theme = new Proxy({}, {
     get(_target, property) {

package/dist/integrations/pi/components/upstream/components/tool-execution.d.ts

@@ -0,0 +1,61 @@
+import { Container, type TUI } from "#pi-tui";
+import { type ToolDefinition } from "@earendil-works/pi-coding-agent";
+type ToolPresentationResult = Parameters<NonNullable<ToolDefinition["renderResult"]>>[0] & {
+    isError: boolean;
+};
+export interface ToolExecutionOptions {
+    showImages?: boolean;
+    imageWidthCells?: number;
+}
+export declare class ToolExecutionComponent extends Container {
+    private contentBox;
+    private contentText;
+    private selfRenderContainer;
+    private callRendererComponent;
+    private resultRendererComponent;
+    private rendererState;
+    private imageComponents;
+    private readonly images;
+    private disposed;
+    private updatingDisplay;
+    private imageSpacers;
+    private toolName;
+    private toolCallId;
+    private args;
+    private expanded;
+    private showImages;
+    private imageWidthCells;
+    private isPartial;
+    private toolDefinition;
+    private builtInToolDefinition;
+    private ui;
+    private cwd;
+    private executionStarted;
+    private argsComplete;
+    private result;
+    private hideComponent;
+    constructor(toolName: string, toolCallId: string, args: any, options: ToolExecutionOptions | undefined, toolDefinition: ToolDefinition<any, any> | undefined, ui: TUI, cwd: string);
+    private getCallRenderer;
+    private getResultRenderer;
+    private hasRendererDefinition;
+    private getRenderShell;
+    private getRenderContext;
+    private createCallFallback;
+    private createResultFallback;
+    updateArgs(args: any): void;
+    markExecutionStarted(): void;
+    setArgsComplete(): void;
+    updateResult(result: ToolPresentationResult, isPartial?: boolean): void;
+    /** End mount ownership without letting an obsolete conversion or extension callback repaint. */
+    dispose(): void;
+    setExpanded(expanded: boolean): void;
+    setShowImages(show: boolean): void;
+    setImageWidthCells(width: number): void;
+    invalidate(): void;
+    render(width: number): string[];
+    private updateDisplay;
+    private composeDisplay;
+    private getTextOutput;
+    private formatToolExecution;
+}
+export {};

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/engine/adapter.d.ts

@@ -213,7 +213,10 @@ export declare class PiEngineAdapter implements OwnedUiPromptSuggestionGenerator
         readonly description: string;
     }[];
     pinnedToolDefinition(toolName: string): unknown;
-    copyWorkflowText(text: string): Promise<void>;
+    /** Bind the owned UI's clipboard lifecycle without changing the comparison host. True means acknowledged delivery. */
+    bindClipboardWriter(writer: (text: string) => Promise<boolean>): () => void;
+    /** Workflow and tree copying share the active owner's write fence and delivery acknowledgment. */
+    copyWorkflowText(text: string): Promise<boolean>;
     clearQueuedWorkflows(): readonly string[];
     abortBashWorkflow(): void;
     executeBashWorkflow(command: string, excludeFromContext: boolean): Promise<PiBashWorkflowResult>;