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

package/dist/integrations/pi/components/upstream/components/earendil-announcement.js

@@ -0,0 +1,42 @@
+// Mechanically adapted from Pi commit 914cf14
+// packages/coding-agent/src/modes/interactive/components/earendil-announcement.ts (MIT).
+// Local modifications: remap private imports to public package-root/owned theme boundaries; load the verified owned copy of the image lazily.
+import { readFileSync } from "node:fs";
+import { Container, Image, Spacer, Text } from "#pi-tui";
+import { DynamicBorder } from "@earendil-works/pi-coding-agent";
+import { piTheme } from "../theme/theme.js";
+const BLOG_URL = "https://mariozechner.at/posts/2026-04-08-ive-sold-out/";
+const IMAGE_FILENAME = "clankolas.png";
+let cachedImageBase64;
+let attemptedImageLoad = false;
+function loadImageBase64() {
+    if (attemptedImageLoad)
+        return cachedImageBase64;
+    attemptedImageLoad = true;
+    try {
+        const resource = JSON.parse(readFileSync(new URL("../assets/earendil-image.json", import.meta.url), "utf8"));
+        if (resource && typeof resource === "object" && "data" in resource && typeof resource.data === "string")
+            cachedImageBase64 = resource.data;
+    }
+    catch {
+        cachedImageBase64 = undefined;
+    }
+    return cachedImageBase64;
+}
+export class EarendilAnnouncementComponent extends Container {
+    constructor() {
+        super();
+        this.addChild(new DynamicBorder((text) => piTheme().fg("accent", text)));
+        this.addChild(new Text(piTheme().bold(piTheme().fg("accent", "pi has joined Earendil")), 1, 0));
+        this.addChild(new Spacer(1));
+        this.addChild(new Text(piTheme().fg("muted", "Read the blog post:"), 1, 0));
+        this.addChild(new Text(piTheme().fg("mdLink", BLOG_URL), 1, 0));
+        this.addChild(new Spacer(1));
+        const imageBase64 = loadImageBase64();
+        if (imageBase64) {
+            this.addChild(new Image(imageBase64, "image/png", { fallbackColor: text => piTheme().fg("muted", text) }, { maxWidthCells: 56, filename: IMAGE_FILENAME }));
+            this.addChild(new Spacer(1));
+        }
+        this.addChild(new DynamicBorder((text) => piTheme().fg("accent", text)));
+    }
+}

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

@@ -0,0 +1,40 @@
+/**
+ * Adapted from @earendil-works/pi-coding-agent 0.84.2
+ * packages/coding-agent/src/modes/interactive/components/custom-editor.ts (MIT).
+ * Modifications: A1-owned class name, synchronized keybinding contract, and a semantic
+ * injected bare-A1 input-frame/contextual-suggestion presentation with explicit body geometry.
+ */
+import { type EditorOptions, type EditorTheme, type TUI } from "#pi-tui";
+import type { AppKeybinding, KeybindingsManager } from "../adjacent/core/keybindings.js";
+import type { EditorSurface } from "../../editor-interaction.js";
+import type { PiShellPromptInputPresentation } from "../../prompt-input-port.js";
+export interface OwnedEditorOptions extends EditorOptions {
+    readonly persistentHistory?: boolean;
+    readonly styleHistoryLabel?: (text: string) => string;
+    readonly inputPresentation?: PiShellPromptInputPresentation;
+    readonly styleSuggestion?: (text: string) => string;
+    readonly styleSuggestionCaret?: (text: string) => string;
+    readonly terminalRows?: () => number;
+    /** Reuses the editor's established atomic-aware visual layout when available. */
+    readonly getVisualLineCount?: (width: number) => number | undefined;
+}
+export interface ShellEditorInstance extends EditorSurface {
+    readonly actionHandlers: Map<AppKeybinding, () => void>;
+    onEscape?: () => void;
+    onCtrlD?: () => void;
+    onPasteImage?: () => void;
+    onExtensionShortcut?: (data: string) => boolean;
+    onPromptSuggestionAccepted?: (text: string) => void;
+    /** Border-inclusive body height from the most recent render, excluding autocomplete. */
+    getRenderedBodyRowCount(): number;
+    setPromptSuggestion(text: string | null): void;
+    canPresentPromptSuggestion(): boolean;
+    onAction(action: AppKeybinding, handler: () => void): void;
+}
+type EditorConstructor = new (tui: TUI, theme: EditorTheme, options?: EditorOptions) => EditorSurface;
+type ShellEditorConstructor = new (tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager, options?: OwnedEditorOptions) => ShellEditorInstance;
+export declare function createOwnedEditorClass(Base: EditorConstructor): ShellEditorConstructor;
+declare const OwnedEditor_base: ShellEditorConstructor;
+export declare class OwnedEditor extends OwnedEditor_base {
+}
+export {};

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

@@ -0,0 +1,166 @@
+/**
+ * Adapted from @earendil-works/pi-coding-agent 0.84.2
+ * packages/coding-agent/src/modes/interactive/components/custom-editor.ts (MIT).
+ * Modifications: A1-owned class name, synchronized keybinding contract, and a semantic
+ * injected bare-A1 input-frame/contextual-suggestion presentation with explicit body geometry.
+ */
+import { CURSOR_MARKER, Editor, visibleWidth, wrapTextWithAnsi, } from "#pi-tui";
+const PROMPT_GRAPHEMES = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+export function createOwnedEditorClass(Base) {
+    return class extends Base {
+        keybindings;
+        actionHandlers = new Map();
+        onEscape;
+        onCtrlD;
+        onPasteImage;
+        onExtensionShortcut;
+        onPromptSuggestionAccepted;
+        #promptSuggestion = null;
+        #inputPresentation;
+        #styleSuggestion;
+        #styleSuggestionCaret;
+        #terminalRows;
+        #getVisualLineCount;
+        #renderedBodyRowCount = 0;
+        constructor(tui, theme, keybindings, options = {}) {
+            super(tui, theme, options);
+            this.keybindings = keybindings;
+            this.#inputPresentation = options.inputPresentation;
+            this.#styleSuggestion = options.styleSuggestion ?? (text => text);
+            this.#styleSuggestionCaret = options.styleSuggestionCaret ?? (text => `\u001b[7m${text}\u001b[27m`);
+            this.#terminalRows = options.terminalRows ?? (() => 24);
+            this.#getVisualLineCount = options.getVisualLineCount;
+        }
+        getRenderedBodyRowCount() { return this.#renderedBodyRowCount; }
+        setPromptSuggestion(text) {
+            this.#promptSuggestion = text;
+        }
+        canPresentPromptSuggestion() {
+            return this.#inputPresentation !== undefined
+                && this.focused
+                && !this.disableSubmit
+                && this.getText().length === 0
+                && !this.isShowingAutocomplete();
+        }
+        setText(text) {
+            if (text.length > 0)
+                this.#promptSuggestion = null;
+            super.setText(text);
+        }
+        render(width) {
+            if (this.#inputPresentation === undefined) {
+                const rows = super.render(width);
+                this.#renderedBodyRowCount = this.#getVisualLineCount === undefined ? rows.length : this.#measureBodyRows(width);
+                return rows;
+            }
+            if (this.#promptSuggestion !== null && this.canPresentPromptSuggestion()) {
+                const rows = this.#renderSuggestion(width);
+                this.#renderedBodyRowCount = rows.length;
+                return rows;
+            }
+            return this.#renderPrefixedEditor(width);
+        }
+        onAction(action, handler) { this.actionHandlers.set(action, handler); }
+        handleInput(data) {
+            if (this.onExtensionShortcut?.(data))
+                return;
+            if (this.#promptSuggestion !== null
+                && !this.isShowingAutocomplete()
+                && this.canPresentPromptSuggestion()
+                && this.keybindings.matches(data, "tui.input.submit")) {
+                return;
+            }
+            if (this.#promptSuggestion !== null
+                && !this.isShowingAutocomplete()
+                && this.canPresentPromptSuggestion()
+                && this.keybindings.matches(data, "tui.input.tab")) {
+                const accepted = this.#promptSuggestion;
+                this.#promptSuggestion = null;
+                super.setText(accepted);
+                this.onPromptSuggestionAccepted?.(accepted);
+                return;
+            }
+            if (this.keybindings.matches(data, "app.clipboard.pasteImage")) {
+                this.onPasteImage?.();
+                return;
+            }
+            if (this.keybindings.matches(data, "app.interrupt")) {
+                if (!this.isShowingAutocomplete()) {
+                    const handler = this.onEscape ?? this.actionHandlers.get("app.interrupt");
+                    if (handler) {
+                        handler();
+                        return;
+                    }
+                }
+                super.handleInput(data);
+                return;
+            }
+            if (this.keybindings.matches(data, "app.exit") && this.getText().length === 0) {
+                const handler = this.onCtrlD ?? this.actionHandlers.get("app.exit");
+                if (handler)
+                    handler();
+                return;
+            }
+            if (this.keybindings.matches(data, "tui.editor.historyPrevious") || this.keybindings.matches(data, "tui.editor.historyNext")) {
+                super.handleInput(data);
+                return;
+            }
+            for (const [action, handler] of this.actionHandlers) {
+                if (action !== "app.interrupt" && action !== "app.exit" && this.keybindings.matches(data, action)) {
+                    handler();
+                    return;
+                }
+            }
+            super.handleInput(data);
+        }
+        #renderSuggestion(width) {
+            const presentation = this.#inputPresentation;
+            const { paddingX, contentWidth, layoutWidth } = presentation.geometry(width, this.getPaddingX());
+            const chunks = wrapTextWithAnsi(this.#promptSuggestion ?? "", layoutWidth).map(text => ({ text }));
+            const maxVisible = Math.max(5, Math.floor(this.#terminalRows() * 0.3));
+            const visible = chunks.slice(0, maxVisible);
+            const leftPadding = " ".repeat(paddingX);
+            const rightPadding = leftPadding;
+            const rows = visible.map((chunk, index) => {
+                let content;
+                if (index === 0) {
+                    const first = [...PROMPT_GRAPHEMES.segment(chunk.text)][0]?.segment ?? " ";
+                    const remaining = chunk.text.slice(first === " " && chunk.text.length === 0 ? 0 : first.length);
+                    const marker = this.focused ? CURSOR_MARKER : "";
+                    content = `${marker}${this.#styleSuggestionCaret(first)}${this.#styleSuggestion(remaining)}`;
+                }
+                else {
+                    content = this.#styleSuggestion(chunk.text);
+                }
+                const plainWidth = visibleWidth(chunk.text);
+                const padding = " ".repeat(Math.max(0, contentWidth - plainWidth));
+                return `${leftPadding}${content}${padding}${rightPadding}`;
+            });
+            return presentation.render(width, () => ({ rows }));
+        }
+        #renderPrefixedEditor(width) {
+            return this.#inputPresentation.render(width, innerWidth => {
+                const rows = super.render(innerWidth);
+                this.#renderedBodyRowCount = this.#measureBodyRows(innerWidth);
+                const bottomBorder = this.#renderedBodyRowCount - 1;
+                return {
+                    rows: rows.slice(1, bottomBorder),
+                    topRule: rows[0],
+                    bottomRule: rows[bottomBorder],
+                    after: rows.slice(bottomBorder + 1),
+                };
+            }, true, this.getPaddingX());
+        }
+        #measureBodyRows(width) {
+            const padding = Math.min(this.getPaddingX(), Math.max(0, Math.floor((width - 1) / 2)));
+            const contentWidth = Math.max(1, width - padding * 2);
+            const layoutWidth = Math.max(1, contentWidth - (padding ? 0 : 1));
+            // Invariant: split by editor layout, never by styled border or completion text.
+            const lineCount = this.#getVisualLineCount?.(layoutWidth)
+                ?? this.getLines().reduce((count, line) => count + wrapTextWithAnsi(line, layoutWidth).length, 0);
+            return Math.min(Math.max(1, lineCount), Math.max(5, Math.floor(this.#terminalRows() * 0.3))) + 2;
+        }
+    };
+}
+export class OwnedEditor extends createOwnedEditorClass(Editor) {
+}

package/dist/{src/foundation/pi-component-adapter → 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/{src/foundation/pi-component-adapter → 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/{src/foundation/pi-component-adapter → integrations/pi/components}/upstream/components/session-footer.d.ts

@@ -1,9 +1,10 @@
 import { type Component } from "#pi-tui";
-import type { OwnedUiSessionViewModel } from "../../../owned-ui-contracts/index.js";
+import type { OwnedUiSessionViewModel } from "../../../../../contracts/owned-ui/index.js";
 export declare class SessionFooter implements Component {
     private readonly getView;
     private readonly cwd;
-    constructor(getView: () => OwnedUiSessionViewModel, cwd: string);
+    private readonly profile;
+    constructor(getView: () => OwnedUiSessionViewModel, cwd: string, profile?: "pi" | "a1");
     invalidate(): void;
     dispose(): void;
     render(width: number): string[];

package/dist/{src/foundation/pi-component-adapter → integrations/pi/components}/upstream/components/session-footer.js

@@ -1,7 +1,8 @@
 /**
  * Adapted from @earendil-works/pi-coding-agent 0.84.2
  * packages/coding-agent/src/modes/interactive/components/footer.ts (MIT).
- * Modifications: consumes neutral owned-UI view data rather than a concrete AgentSession.
+ * Modifications: consumes neutral owned-UI view data rather than a concrete AgentSession;
+ * bare A1 colors the effective level-name span while the comparison profile retains pinned styling.
  */
 import { isAbsolute, relative, resolve, sep } from "node:path";
 import { truncateToWidth, visibleWidth } from "#pi-tui";
@@ -9,9 +10,11 @@ import { piTheme } from "../../theme.js";
 export class SessionFooter {
     getView;
     cwd;
-    constructor(getView, cwd) {
+    profile;
+    constructor(getView, cwd, profile = "pi") {
         this.getView = getView;
         this.cwd = cwd;
+        this.profile = profile;
     }
     invalidate() { }
     dispose() { }
@@ -60,12 +63,14 @@ export class SessionFooter {
             leftWidth = visibleWidth(left);
         }
         const modelName = view.activeModel?.modelId ?? "no-model";
-        const rightWithoutProvider = view.activeModel === null || view.thinkingLevel === "off"
-            ? modelName
-            : `${modelName} • ${view.thinkingLevel}`;
+        const rightWithoutProvider = this.profile === "a1"
+            ? view.activeModel === null ? theme.fg("dim", modelName)
+                : theme.fg("dim", `${modelName} • `) + theme.getThinkingBorderColor(view.thinkingLevel)(view.thinkingLevel)
+            : view.activeModel === null || view.thinkingLevel === "off" ? modelName : `${modelName} • ${view.thinkingLevel}`;
         let right = rightWithoutProvider;
         if ((view.status.footer?.availableProviderCount ?? 1) > 1 && view.activeModel) {
-            right = `(${view.activeModel.providerId}) ${rightWithoutProvider}`;
+            const provider = `(${view.activeModel.providerId}) `;
+            right = (this.profile === "a1" ? theme.fg("dim", provider) : provider) + rightWithoutProvider;
             if (leftWidth + 2 + visibleWidth(right) > width)
                 right = rightWithoutProvider;
         }
@@ -85,7 +90,7 @@ export class SessionFooter {
         }
         const lines = [
             truncateToWidth(theme.fg("dim", pwd), width, theme.fg("dim", "...")),
-            theme.fg("dim", left) + theme.fg("dim", line.slice(left.length)),
+            theme.fg("dim", left) + (this.profile === "a1" ? line.slice(left.length) : theme.fg("dim", line.slice(left.length))),
         ];
         const statuses = view.status.footer?.extensionStatuses ?? [];
         if (statuses.length > 0) {

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 {};