@timurproko/a1 0.1.8-dev.ece8cef → 0.2.1-dev.590

package/dist/integrations/pi/components/upstream/components/skill-invocation-message.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Provenance: @earendil-works/pi-coding-agent 0.87.1 (MIT), commit f07218c4d4bbc12bef056a7058c3dd49dfe41abe,
+ * packages/coding-agent/src/modes/interactive/components/skill-invocation-message.ts.
+ * Modifications: Mechanical port uses A1's public pi-tui instance, owned theme boundary, and
+ * root-instance keybinding registry because the public coding-agent component closes over a second
+ * nested pi-tui singleton and cannot observe A1's keybindings.
+ * Deviations: none.
+ */
+import { Box, type MarkdownTheme } from "@earendil-works/pi-tui";
+export interface SkillInvocationBlock {
+    readonly name: string;
+    readonly content: string;
+}
+export declare class SkillInvocationMessageComponent extends Box {
+    #private;
+    private readonly skillBlock;
+    private readonly markdownTheme;
+    constructor(skillBlock: SkillInvocationBlock, markdownTheme: MarkdownTheme);
+    setExpanded(expanded: boolean): void;
+    invalidate(): void;
+}

package/dist/integrations/pi/components/upstream/components/skill-invocation-message.js

@@ -0,0 +1,54 @@
+/**
+ * Provenance: @earendil-works/pi-coding-agent 0.87.1 (MIT), commit f07218c4d4bbc12bef056a7058c3dd49dfe41abe,
+ * packages/coding-agent/src/modes/interactive/components/skill-invocation-message.ts.
+ * Modifications: Mechanical port uses A1's public pi-tui instance, owned theme boundary, and
+ * root-instance keybinding registry because the public coding-agent component closes over a second
+ * nested pi-tui singleton and cannot observe A1's keybindings.
+ * Deviations: none.
+ */
+import { Box, Container, getKeybindings, Markdown, MouseRegion, Text } from "@earendil-works/pi-tui";
+import { piTheme } from "../theme/theme.js";
+export class SkillInvocationMessageComponent extends Box {
+    #expanded = false;
+    skillBlock;
+    markdownTheme;
+    constructor(skillBlock, markdownTheme) {
+        super(1, 1, text => piTheme().bg("customMessageBg", text));
+        this.skillBlock = skillBlock;
+        this.markdownTheme = markdownTheme;
+        this.#updateDisplay();
+    }
+    setExpanded(expanded) {
+        this.#expanded = expanded;
+        this.#updateDisplay();
+    }
+    invalidate() {
+        super.invalidate();
+        this.#updateDisplay();
+    }
+    #updateDisplay() {
+        this.clear();
+        const content = new Container();
+        if (this.#expanded) {
+            const label = piTheme().fg("customMessageLabel", "\x1b[1m[skill]\x1b[22m");
+            content.addChild(new Text(label, 0, 0));
+            const header = `**${this.skillBlock.name}**\n\n`;
+            content.addChild(new Markdown(header + this.skillBlock.content, 0, 0, this.markdownTheme, {
+                color: text => piTheme().fg("customMessageText", text),
+            }));
+        }
+        else {
+            const expandKey = getKeybindings().getKeys("app.tools.expand")[0] ?? "";
+            const line = piTheme().fg("customMessageLabel", "\x1b[1m[skill]\x1b[22m ")
+                + piTheme().fg("customMessageText", this.skillBlock.name)
+                + piTheme().fg("dim", ` (${expandKey} to expand)`);
+            content.addChild(new Text(line, 0, 0));
+        }
+        this.addChild(new MouseRegion(content, event => {
+            if (event.type !== "click" || event.button !== "left")
+                return undefined;
+            this.setExpanded(!this.#expanded);
+            return { handled: true };
+        }));
+    }
+}

package/dist/integrations/pi/components/upstream/components/status-indicator.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Provenance: @earendil-works/pi-coding-agent 0.87.1 (MIT), commit f07218c4d4bbc12bef056a7058c3dd49dfe41abe,
+ * packages/coding-agent/src/modes/interactive/components/status-indicator.ts.
+ * Modifications: Mechanical source port with public package-root keybinding, Loader, and owned
+ * theme/countdown imports plus ECMAScript private fields.
+ * Deviations: status-indicator-public-boundaries.
+ */
+import { type Component, Loader, type LoaderIndicatorOptions, type TUI } from "@earendil-works/pi-tui";
+export type StatusIndicatorKind = "working" | "retry" | "compaction" | "branchSummary";
+export declare class StatusIndicator extends Loader {
+    readonly kind: StatusIndicatorKind;
+    constructor(kind: StatusIndicatorKind, ui: TUI, spinnerColorFn: (str: string) => string, messageColorFn: (str: string) => string, message: string, indicator?: LoaderIndicatorOptions);
+    renderInBorder(width: number): string;
+    renderSpinnerInBorder(width: number): string;
+    dispose(): void;
+}
+export declare class WorkingStatusIndicator extends StatusIndicator {
+    constructor(ui: TUI, message: string, indicator?: LoaderIndicatorOptions, colorFn?: (text: string) => string);
+}
+export declare class RetryStatusIndicator extends StatusIndicator {
+    #private;
+    constructor(ui: TUI, attempt: number, maxAttempts: number, delayMs: number);
+    dispose(): void;
+}
+export type CompactionStatusReason = "manual" | "threshold" | "overflow";
+export declare class CompactionStatusIndicator extends StatusIndicator {
+    constructor(ui: TUI, reason: CompactionStatusReason);
+}
+export declare class BranchSummaryStatusIndicator extends StatusIndicator {
+    constructor(ui: TUI);
+}
+export declare class IdleStatus implements Component {
+    invalidate(): void;
+    render(width: number): string[];
+}

package/dist/integrations/pi/components/upstream/components/status-indicator.js

@@ -0,0 +1,69 @@
+/**
+ * Provenance: @earendil-works/pi-coding-agent 0.87.1 (MIT), commit f07218c4d4bbc12bef056a7058c3dd49dfe41abe,
+ * packages/coding-agent/src/modes/interactive/components/status-indicator.ts.
+ * Modifications: Mechanical source port with public package-root keybinding, Loader, and owned
+ * theme/countdown imports plus ECMAScript private fields.
+ * Deviations: status-indicator-public-boundaries.
+ */
+import { Loader, truncateToWidth } from "@earendil-works/pi-tui";
+import { keyText } from "../../../startup-public.js";
+import { piTheme } from "../theme/theme.js";
+import { CountdownTimer } from "./countdown-timer.js";
+export class StatusIndicator extends Loader {
+    kind;
+    constructor(kind, ui, spinnerColorFn, messageColorFn, message, indicator) {
+        super(ui, spinnerColorFn, messageColorFn, message, indicator);
+        this.kind = kind;
+    }
+    renderInBorder(width) {
+        const line = super.render(width + 2)[1] ?? "";
+        return truncateToWidth(line.startsWith(" ") ? line.slice(1).trimEnd() : line.trimEnd(), width, "");
+    }
+    renderSpinnerInBorder(width) {
+        return truncateToWidth(this.getRenderedIndicator(), width, "");
+    }
+    dispose() {
+        this.stop();
+    }
+}
+export class WorkingStatusIndicator extends StatusIndicator {
+    constructor(ui, message, indicator, colorFn) {
+        super("working", ui, colorFn ?? (spinner => piTheme().fg("accent", spinner)), colorFn ?? (text => piTheme().fg("muted", text)), message, indicator);
+    }
+}
+export class RetryStatusIndicator extends StatusIndicator {
+    #countdown;
+    constructor(ui, attempt, maxAttempts, delayMs) {
+        const retryMessage = (seconds) => `Retrying (${attempt}/${maxAttempts}) in ${seconds}s... (${keyText("app.interrupt")} to cancel)`;
+        super("retry", ui, spinner => piTheme().fg("warning", spinner), text => piTheme().fg("muted", text), retryMessage(Math.ceil(delayMs / 1000)));
+        this.#countdown = new CountdownTimer(delayMs, ui, seconds => this.setMessage(retryMessage(seconds)), () => {
+            this.#countdown = undefined;
+        });
+    }
+    dispose() {
+        this.#countdown?.dispose();
+        this.#countdown = undefined;
+        super.dispose();
+    }
+}
+export class CompactionStatusIndicator extends StatusIndicator {
+    constructor(ui, reason) {
+        const cancelHint = `(${keyText("app.interrupt")} to cancel)`;
+        const label = reason === "manual"
+            ? `Compacting context... ${cancelHint}`
+            : `${reason === "overflow" ? "Context overflow detected, " : ""}Auto-compacting... ${cancelHint}`;
+        super("compaction", ui, spinner => piTheme().fg("accent", spinner), text => piTheme().fg("muted", text), label);
+    }
+}
+export class BranchSummaryStatusIndicator extends StatusIndicator {
+    constructor(ui) {
+        super("branchSummary", ui, spinner => piTheme().fg("accent", spinner), text => piTheme().fg("muted", text), `Summarizing branch... (${keyText("app.interrupt")} to cancel)`);
+    }
+}
+export class IdleStatus {
+    invalidate() { }
+    render(width) {
+        const emptyLine = " ".repeat(width);
+        return [emptyLine, emptyLine];
+    }
+}

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

@@ -0,0 +1,36 @@
+/**
+ * Provenance: @earendil-works/pi-coding-agent 0.87.1 (MIT), commit f07218c4d4bbc12bef056a7058c3dd49dfe41abe,
+ * packages/coding-agent/src/modes/interactive/components/thinking-selector.ts.
+ * Modifications: Preserve the searchable thinking-level selector, current/default semantics,
+ * selection, save, cancellation, and focus while accepting the active bare-A1 cycle-key label from the
+ * shell, styling the title with the established bold semantic accent treatment, placing it directly
+ * below the top rule through the shared compact padded modal frame and its muted hint directly below
+ * it, deduplicating levels, and rendering aligned muted descriptions after adjacent active and
+ * bracketed default markers. All list and border colors use the owned theme and its explicit color
+ * mode, and the footer uses the shared bare-A1 modal shortcut row. The comparison profile retains the
+ * public pinned component.
+ * Deviations: owned-modal-shortcut-hints, owned-level-cycle-shortcut, owned-thinking-selector-heading.
+ */
+import { Container, type Focusable, SelectList } from "@earendil-works/pi-tui";
+export type ThinkingSelectorLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+/** Bare-A1 thinking-level selector with profile-resolved shortcut presentation. */
+export declare class OwnedThinkingSelectorComponent extends Container implements Focusable {
+    private searchInput;
+    private selectList;
+    private selectListContainer;
+    private allItems;
+    private onSelect;
+    private onCancel;
+    private onSelectAsDefault;
+    private currentLevel;
+    private defaultThinkingLevel;
+    private _focused;
+    get focused(): boolean;
+    set focused(value: boolean);
+    constructor(currentLevel: ThinkingSelectorLevel, availableLevels: ThinkingSelectorLevel[], onSelect: (level: ThinkingSelectorLevel) => void, onCancel: () => void, cycleKeyDisplay: string, onSelectAsDefault?: (level: ThinkingSelectorLevel) => void, defaultThinkingLevel?: ThinkingSelectorLevel);
+    private keyDisplayText;
+    private buildSelectList;
+    private applyFilter;
+    handleInput(keyData: string): void;
+    getSelectList(): SelectList;
+}

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

@@ -0,0 +1,153 @@
+/**
+ * Provenance: @earendil-works/pi-coding-agent 0.87.1 (MIT), commit f07218c4d4bbc12bef056a7058c3dd49dfe41abe,
+ * packages/coding-agent/src/modes/interactive/components/thinking-selector.ts.
+ * Modifications: Preserve the searchable thinking-level selector, current/default semantics,
+ * selection, save, cancellation, and focus while accepting the active bare-A1 cycle-key label from the
+ * shell, styling the title with the established bold semantic accent treatment, placing it directly
+ * below the top rule through the shared compact padded modal frame and its muted hint directly below
+ * it, deduplicating levels, and rendering aligned muted descriptions after adjacent active and
+ * bracketed default markers. All list and border colors use the owned theme and its explicit color
+ * mode, and the footer uses the shared bare-A1 modal shortcut row. The comparison profile retains the
+ * public pinned component.
+ * Deviations: owned-modal-shortcut-hints, owned-level-cycle-shortcut, owned-thinking-selector-heading.
+ */
+import { Container, fuzzyFilter, getKeybindings, Input, SelectList, Spacer, Text, } from "@earendil-works/pi-tui";
+import { DynamicBorder } from "../../../startup-public.js";
+import { addPiModalHeader, adoptPiModalFrame } from "../../modal-frame.js";
+import { piTheme, renderPiModalShortcutHints } from "../../theme.js";
+const THINKING_SELECT_LIST_LAYOUT = {
+    minPrimaryColumnWidth: 12,
+    maxPrimaryColumnWidth: 32,
+};
+const LEVEL_DESCRIPTIONS = {
+    off: "No reasoning",
+    minimal: "Very brief reasoning (~1k tokens)",
+    low: "Light reasoning (~2k tokens)",
+    medium: "Moderate reasoning (~8k tokens)",
+    high: "Deep reasoning (~16k tokens)",
+    xhigh: "Extra-high reasoning (~32k tokens)",
+    max: "Maximum reasoning",
+};
+/** Bare-A1 thinking-level selector with profile-resolved shortcut presentation. */
+export class OwnedThinkingSelectorComponent extends Container {
+    searchInput;
+    selectList;
+    selectListContainer;
+    allItems;
+    onSelect;
+    onCancel;
+    onSelectAsDefault;
+    currentLevel;
+    defaultThinkingLevel;
+    _focused = false;
+    get focused() {
+        return this._focused;
+    }
+    set focused(value) {
+        this._focused = value;
+        this.searchInput.focused = value;
+    }
+    constructor(currentLevel, availableLevels, onSelect, onCancel, cycleKeyDisplay, onSelectAsDefault, defaultThinkingLevel) {
+        super();
+        this.onSelect = onSelect;
+        this.onCancel = onCancel;
+        this.onSelectAsDefault = onSelectAsDefault;
+        this.currentLevel = currentLevel;
+        this.defaultThinkingLevel = defaultThinkingLevel;
+        this.allItems = [...new Set(availableLevels)].map((level) => ({
+            value: level,
+            label: level,
+            description: LEVEL_DESCRIPTIONS[level],
+        }));
+        const header = addPiModalHeader(this, new DynamicBorder((text) => piTheme().fg("border", text)), new Text(piTheme().fg("accent", piTheme().bold("Thinking Level")), 0, 0));
+        this.addChild(new Text(piTheme().fg("muted", `${cycleKeyDisplay} cycles thinking levels in-session`), 0, 0));
+        this.addChild(new Spacer(1));
+        this.searchInput = new Input();
+        this.searchInput.onSubmit = () => this.selectList.handleInput("\r");
+        this.addChild(this.searchInput);
+        this.addChild(new Spacer(1));
+        this.selectList = this.buildSelectList(this.allItems, currentLevel);
+        this.selectListContainer = new Container();
+        this.selectListContainer.addChild(this.selectList);
+        this.addChild(this.selectListContainer);
+        this.addChild(new Spacer(1));
+        this.addChild(new Text(renderPiModalShortcutHints([
+            { key: this.keyDisplayText("tui.select.confirm"), action: "to select" },
+            { key: this.keyDisplayText("app.thinking.save"), action: "to set as default" },
+            { key: this.keyDisplayText("tui.select.cancel"), action: "to cancel" },
+        ]), 0, 0));
+        this.addChild(new DynamicBorder((text) => piTheme().fg("border", text)));
+        adoptPiModalFrame(this, { topIndex: 0, bottomIndex: this.children.length - 1, header });
+    }
+    keyDisplayText(keybinding) {
+        return getKeybindings().getKeys(keybinding)
+            .map((key) => key.split("+").map((part) => {
+            const display = process.platform === "darwin" && part.toLowerCase() === "alt" ? "option" : part;
+            return display.charAt(0).toUpperCase() + display.slice(1);
+        }).join("+"))
+            .join("/");
+    }
+    buildSelectList(items, preselect) {
+        const markerWidth = (item) => (item.value === this.currentLevel ? 2 : 0) + (item.value === this.defaultThinkingLevel ? 10 : 0);
+        const primaryWidth = this.allItems.reduce((widest, item) => {
+            const level = item.label ?? item.value;
+            return Math.max(widest, level.length + markerWidth(item));
+        }, 0);
+        const themedItems = items.map((item) => {
+            const level = item.label ?? item.value;
+            const currentMarker = item.value === this.currentLevel ? ` ${piTheme().fg("success", "✓")}` : "";
+            const defaultMarker = item.value === this.defaultThinkingLevel
+                ? ` ${piTheme().fg("muted", "[default]")}`
+                : "";
+            const separator = " ".repeat(Math.max(1, primaryWidth - level.length - markerWidth(item) + 1));
+            const description = item.description ? piTheme().fg("muted", item.description) : "";
+            return { value: item.value, label: `${level}${currentMarker}${defaultMarker}${separator}${description}` };
+        });
+        // Invariant: the bare selector uses the owned theme's explicit color mode, not upstream's host detection.
+        const list = new SelectList(themedItems, Math.max(1, themedItems.length), {
+            selectedPrefix: text => piTheme().fg("accent", text),
+            selectedText: text => piTheme().fg("accent", text),
+            description: text => piTheme().fg("muted", text),
+            scrollInfo: text => piTheme().fg("muted", text),
+            noMatch: text => piTheme().fg("muted", text),
+        }, THINKING_SELECT_LIST_LAYOUT);
+        const currentIndex = themedItems.findIndex((item) => item.value === preselect);
+        if (currentIndex !== -1)
+            list.setSelectedIndex(currentIndex);
+        list.onSelect = (item) => this.onSelect(item.value);
+        list.onCancel = () => this.onCancel();
+        return list;
+    }
+    applyFilter(query) {
+        const filtered = query
+            ? fuzzyFilter(this.allItems, query, (item) => `${item.value} ${item.description ?? ""}`)
+            : this.allItems;
+        const selectedValue = this.selectList.getSelectedItem()?.value;
+        const newList = this.buildSelectList(filtered, selectedValue);
+        this.selectListContainer.clear();
+        this.selectListContainer.addChild(newList);
+        this.selectList = newList;
+    }
+    handleInput(keyData) {
+        const kb = getKeybindings();
+        if (kb.matches(keyData, "app.thinking.save") && this.onSelectAsDefault) {
+            const item = this.selectList.getSelectedItem();
+            if (item)
+                this.onSelectAsDefault(item.value);
+            return;
+        }
+        const isNav = kb.matches(keyData, "tui.select.up") ||
+            kb.matches(keyData, "tui.select.down") ||
+            kb.matches(keyData, "tui.select.confirm") ||
+            kb.matches(keyData, "tui.select.cancel");
+        if (isNav) {
+            this.selectList.handleInput(keyData);
+            return;
+        }
+        this.searchInput.handleInput(keyData);
+        this.applyFilter(this.searchInput.getValue());
+    }
+    getSelectList() {
+        return this.selectList;
+    }
+}

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

@@ -0,0 +1,67 @@
+import { Container, type TUI, type TuiMouseEvent } from "@earendil-works/pi-tui";
+import { type ToolDefinition } from "@earendil-works/pi-coding-agent";
+type ToolPresentationResult = Parameters<NonNullable<ToolDefinition["renderResult"]>>[0] & {
+    isError: boolean;
+};
+/** The caller-side merge 0.85.1 performs before handing a definition to the component: built-in renderers fill the gaps. */
+export declare function mergeBuiltInRenderers(definition: ToolDefinition<any, any, any> | undefined, builtIn: ToolDefinition<any, any, any> | undefined): ToolDefinition<any, any, any> | undefined;
+export interface ToolExecutionOptions {
+    showImages?: boolean;
+    imageWidthCells?: number;
+}
+export declare class ToolExecutionComponent extends Container {
+    private contentBox;
+    private contentText;
+    private contentTextRegion;
+    private selfRenderContainer;
+    private selfRenderHeight;
+    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, any> | undefined, ui: TUI, cwd: string);
+    private getCallRenderer;
+    private getResultRenderer;
+    private hasRendererDefinition;
+    private getRenderShell;
+    private getRenderContext;
+    private createCallFallback;
+    private createResultFallback;
+    private createResultRegion;
+    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[];
+    handleMouse(event: TuiMouseEvent): ReturnType<Container["handleMouse"]>;
+    private updateDisplay;
+    private composeDisplay;
+    private getTextOutput;
+    private formatToolExecution;
+}
+export {};