@andorra-labs/code 0.0.0-stage → 0.1.5

package/dist/vendor/engine/runtime/coding-agent/modes/interactive/components/armin.js

@@ -0,0 +1,332 @@
+/**
+ * Armin says hi! A fun easter egg with animated XBM art.
+ */
+import { theme } from "../theme/theme.js";
+// XBM image: 31x36 pixels, LSB first, 1=background, 0=foreground
+const WIDTH = 31;
+const HEIGHT = 36;
+const BITS = [
+    0xff, 0xff, 0xff, 0x7f, 0xff, 0xf0, 0xff, 0x7f, 0xff, 0xed, 0xff, 0x7f, 0xff, 0xdb, 0xff, 0x7f, 0xff, 0xb7, 0xff,
+    0x7f, 0xff, 0x77, 0xfe, 0x7f, 0x3f, 0xf8, 0xfe, 0x7f, 0xdf, 0xff, 0xfe, 0x7f, 0xdf, 0x3f, 0xfc, 0x7f, 0x9f, 0xc3,
+    0xfb, 0x7f, 0x6f, 0xfc, 0xf4, 0x7f, 0xf7, 0x0f, 0xf7, 0x7f, 0xf7, 0xff, 0xf7, 0x7f, 0xf7, 0xff, 0xe3, 0x7f, 0xf7,
+    0x07, 0xe8, 0x7f, 0xef, 0xf8, 0x67, 0x70, 0x0f, 0xff, 0xbb, 0x6f, 0xf1, 0x00, 0xd0, 0x5b, 0xfd, 0x3f, 0xec, 0x53,
+    0xc1, 0xff, 0xef, 0x57, 0x9f, 0xfd, 0xee, 0x5f, 0x9f, 0xfc, 0xae, 0x5f, 0x1f, 0x78, 0xac, 0x5f, 0x3f, 0x00, 0x50,
+    0x6c, 0x7f, 0x00, 0xdc, 0x77, 0xff, 0xc0, 0x3f, 0x78, 0xff, 0x01, 0xf8, 0x7f, 0xff, 0x03, 0x9c, 0x78, 0xff, 0x07,
+    0x8c, 0x7c, 0xff, 0x0f, 0xce, 0x78, 0xff, 0xff, 0xcf, 0x7f, 0xff, 0xff, 0xcf, 0x78, 0xff, 0xff, 0xdf, 0x78, 0xff,
+    0xff, 0xdf, 0x7d, 0xff, 0xff, 0x3f, 0x7e, 0xff, 0xff, 0xff, 0x7f,
+];
+const BYTES_PER_ROW = Math.ceil(WIDTH / 8);
+const DISPLAY_HEIGHT = Math.ceil(HEIGHT / 2); // Half-block rendering
+const EFFECTS = ["typewriter", "scanline", "rain", "fade", "crt", "glitch", "dissolve"];
+// Get pixel at (x, y): true = foreground, false = background
+function andorraGetPixel(x, y) {
+    if (y >= HEIGHT)
+        return false;
+    const byteIndex = y * BYTES_PER_ROW + Math.floor(x / 8);
+    const bitIndex = x % 8;
+    return ((BITS[byteIndex] >> bitIndex) & 1) === 0;
+}
+// Get the character for a cell (2 vertical pixels packed)
+function andorraGetChar(x, row) {
+    const upper = andorraGetPixel(x, row * 2);
+    const lower = andorraGetPixel(x, row * 2 + 1);
+    if (upper && lower)
+        return "█";
+    if (upper)
+        return "▀";
+    if (lower)
+        return "▄";
+    return " ";
+}
+// Build the final image grid
+function andorraBuildFinalGrid() {
+    const grid = [];
+    for (let row = 0; row < DISPLAY_HEIGHT; row++) {
+        const line = [];
+        for (let x = 0; x < WIDTH; x++) {
+            line.push(andorraGetChar(x, row));
+        }
+        grid.push(line);
+    }
+    return grid;
+}
+export class AndorraArminComponent {
+    ui;
+    interval = null;
+    effect;
+    finalGrid;
+    currentGrid;
+    effectState = {};
+    cachedLines = [];
+    cachedWidth = 0;
+    gridVersion = 0;
+    cachedVersion = -1;
+    constructor(ui) {
+        this.ui = ui;
+        this.effect = EFFECTS[Math.floor(Math.random() * EFFECTS.length)];
+        this.finalGrid = andorraBuildFinalGrid();
+        this.currentGrid = this.createEmptyGrid();
+        this.initEffect();
+        this.startAnimation();
+    }
+    invalidate() {
+        this.cachedWidth = 0;
+    }
+    render(width) {
+        if (width === this.cachedWidth && this.cachedVersion === this.gridVersion) {
+            return this.cachedLines;
+        }
+        const padding = 1;
+        const availableWidth = width - padding;
+        this.cachedLines = this.currentGrid.map((row) => {
+            // Clip row to available width before applying color
+            const clipped = row.slice(0, availableWidth).join("");
+            const padRight = Math.max(0, width - padding - clipped.length);
+            return ` ${theme.fg("accent", clipped)}${" ".repeat(padRight)}`;
+        });
+        // Add "ARMIN SAYS HI" at the end
+        const message = "ARMIN SAYS HI";
+        const msgPadRight = Math.max(0, width - padding - message.length);
+        this.cachedLines.push(` ${theme.fg("accent", message)}${" ".repeat(msgPadRight)}`);
+        this.cachedWidth = width;
+        this.cachedVersion = this.gridVersion;
+        return this.cachedLines;
+    }
+    createEmptyGrid() {
+        return Array.from({ length: DISPLAY_HEIGHT }, () => Array(WIDTH).fill(" "));
+    }
+    initEffect() {
+        switch (this.effect) {
+            case "typewriter":
+                this.effectState = { pos: 0 };
+                break;
+            case "scanline":
+                this.effectState = { row: 0 };
+                break;
+            case "rain":
+                // Track falling position for each column
+                this.effectState = {
+                    drops: Array.from({ length: WIDTH }, () => ({
+                        y: -Math.floor(Math.random() * DISPLAY_HEIGHT * 2),
+                        settled: 0,
+                    })),
+                };
+                break;
+            case "fade": {
+                // Shuffle all pixel positions
+                const positions = [];
+                for (let row = 0; row < DISPLAY_HEIGHT; row++) {
+                    for (let x = 0; x < WIDTH; x++) {
+                        positions.push([row, x]);
+                    }
+                }
+                // Fisher-Yates shuffle
+                for (let i = positions.length - 1; i > 0; i--) {
+                    const j = Math.floor(Math.random() * (i + 1));
+                    [positions[i], positions[j]] = [positions[j], positions[i]];
+                }
+                this.effectState = { positions, idx: 0 };
+                break;
+            }
+            case "crt":
+                this.effectState = { expansion: 0 };
+                break;
+            case "glitch":
+                this.effectState = { phase: 0, glitchFrames: 8 };
+                break;
+            case "dissolve": {
+                // Start with random noise
+                this.currentGrid = Array.from({ length: DISPLAY_HEIGHT }, () => Array.from({ length: WIDTH }, () => {
+                    const chars = [" ", "░", "▒", "▓", "█", "▀", "▄"];
+                    return chars[Math.floor(Math.random() * chars.length)];
+                }));
+                // Shuffle positions for gradual resolve
+                const dissolvePositions = [];
+                for (let row = 0; row < DISPLAY_HEIGHT; row++) {
+                    for (let x = 0; x < WIDTH; x++) {
+                        dissolvePositions.push([row, x]);
+                    }
+                }
+                for (let i = dissolvePositions.length - 1; i > 0; i--) {
+                    const j = Math.floor(Math.random() * (i + 1));
+                    [dissolvePositions[i], dissolvePositions[j]] = [dissolvePositions[j], dissolvePositions[i]];
+                }
+                this.effectState = { positions: dissolvePositions, idx: 0 };
+                break;
+            }
+        }
+    }
+    startAnimation() {
+        const fps = this.effect === "glitch" ? 60 : 30;
+        this.interval = setInterval(() => {
+            const done = this.tickEffect();
+            this.updateDisplay();
+            this.ui.requestRender();
+            if (done) {
+                this.stopAnimation();
+            }
+        }, 1000 / fps);
+    }
+    stopAnimation() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+    }
+    tickEffect() {
+        switch (this.effect) {
+            case "typewriter":
+                return this.tickTypewriter();
+            case "scanline":
+                return this.tickScanline();
+            case "rain":
+                return this.tickRain();
+            case "fade":
+                return this.tickFade();
+            case "crt":
+                return this.tickCrt();
+            case "glitch":
+                return this.tickGlitch();
+            case "dissolve":
+                return this.tickDissolve();
+            default:
+                return true;
+        }
+    }
+    tickTypewriter() {
+        const state = this.effectState;
+        const pixelsPerFrame = 3;
+        for (let i = 0; i < pixelsPerFrame; i++) {
+            const row = Math.floor(state.pos / WIDTH);
+            const x = state.pos % WIDTH;
+            if (row >= DISPLAY_HEIGHT)
+                return true;
+            this.currentGrid[row][x] = this.finalGrid[row][x];
+            state.pos++;
+        }
+        return false;
+    }
+    tickScanline() {
+        const state = this.effectState;
+        if (state.row >= DISPLAY_HEIGHT)
+            return true;
+        // Copy row
+        for (let x = 0; x < WIDTH; x++) {
+            this.currentGrid[state.row][x] = this.finalGrid[state.row][x];
+        }
+        state.row++;
+        return false;
+    }
+    tickRain() {
+        const state = this.effectState;
+        let allSettled = true;
+        this.currentGrid = this.createEmptyGrid();
+        for (let x = 0; x < WIDTH; x++) {
+            const drop = state.drops[x];
+            // Draw settled pixels
+            for (let row = DISPLAY_HEIGHT - 1; row >= DISPLAY_HEIGHT - drop.settled; row--) {
+                if (row >= 0) {
+                    this.currentGrid[row][x] = this.finalGrid[row][x];
+                }
+            }
+            // Check if this column is done
+            if (drop.settled >= DISPLAY_HEIGHT)
+                continue;
+            allSettled = false;
+            // Find the target row for this column (lowest non-space pixel)
+            let targetRow = -1;
+            for (let row = DISPLAY_HEIGHT - 1 - drop.settled; row >= 0; row--) {
+                if (this.finalGrid[row][x] !== " ") {
+                    targetRow = row;
+                    break;
+                }
+            }
+            // Move drop down
+            drop.y++;
+            // Draw falling drop
+            if (drop.y >= 0 && drop.y < DISPLAY_HEIGHT) {
+                if (targetRow >= 0 && drop.y >= targetRow) {
+                    // Settle
+                    drop.settled = DISPLAY_HEIGHT - targetRow;
+                    drop.y = -Math.floor(Math.random() * 5) - 1;
+                }
+                else {
+                    // Still falling
+                    this.currentGrid[drop.y][x] = "▓";
+                }
+            }
+        }
+        return allSettled;
+    }
+    tickFade() {
+        const state = this.effectState;
+        const pixelsPerFrame = 15;
+        for (let i = 0; i < pixelsPerFrame; i++) {
+            if (state.idx >= state.positions.length)
+                return true;
+            const [row, x] = state.positions[state.idx];
+            this.currentGrid[row][x] = this.finalGrid[row][x];
+            state.idx++;
+        }
+        return false;
+    }
+    tickCrt() {
+        const state = this.effectState;
+        const midRow = Math.floor(DISPLAY_HEIGHT / 2);
+        this.currentGrid = this.createEmptyGrid();
+        // Draw from middle expanding outward
+        const top = midRow - state.expansion;
+        const bottom = midRow + state.expansion;
+        for (let row = Math.max(0, top); row <= Math.min(DISPLAY_HEIGHT - 1, bottom); row++) {
+            for (let x = 0; x < WIDTH; x++) {
+                this.currentGrid[row][x] = this.finalGrid[row][x];
+            }
+        }
+        state.expansion++;
+        return state.expansion > DISPLAY_HEIGHT;
+    }
+    tickGlitch() {
+        const state = this.effectState;
+        if (state.phase < state.glitchFrames) {
+            // Glitch phase: show corrupted version
+            this.currentGrid = this.finalGrid.map((row) => {
+                const offset = Math.floor(Math.random() * 7) - 3;
+                const glitchRow = [...row];
+                // Random horizontal offset
+                if (Math.random() < 0.3) {
+                    const shifted = glitchRow.slice(offset).concat(glitchRow.slice(0, offset));
+                    return shifted.slice(0, WIDTH);
+                }
+                // Random vertical swap
+                if (Math.random() < 0.2) {
+                    const swapRow = Math.floor(Math.random() * DISPLAY_HEIGHT);
+                    return [...this.finalGrid[swapRow]];
+                }
+                return glitchRow;
+            });
+            state.phase++;
+            return false;
+        }
+        // Final frame: show clean image
+        this.currentGrid = this.finalGrid.map((row) => [...row]);
+        return true;
+    }
+    tickDissolve() {
+        const state = this.effectState;
+        const pixelsPerFrame = 20;
+        for (let i = 0; i < pixelsPerFrame; i++) {
+            if (state.idx >= state.positions.length)
+                return true;
+            const [row, x] = state.positions[state.idx];
+            this.currentGrid[row][x] = this.finalGrid[row][x];
+            state.idx++;
+        }
+        return false;
+    }
+    updateDisplay() {
+        this.gridVersion++;
+    }
+    dispose() {
+        this.stopAnimation();
+    }
+}

package/dist/vendor/engine/runtime/coding-agent/modes/interactive/components/assistant-message.d.ts

@@ -0,0 +1,25 @@
+import type { AssistantMessage } from "../../../../ai/index.js";
+import { AndorraContainer, type MarkdownTheme } from "../../../../tui/index.js";
+import type { MarkdownTransformer } from "../../../core/extensions/types.js";
+/**
+ * Component that renders a complete assistant message
+ */
+export declare class AndorraAssistantMessageComponent extends AndorraContainer {
+    private contentContainer;
+    private hideThinkingBlock;
+    private markdownTheme;
+    private hiddenThinkingLabel;
+    private outputPad;
+    private markdownTransformers;
+    private lastMessage?;
+    private hasToolCalls;
+    private isStreaming;
+    private thinkingVisibilityOverrides;
+    constructor(message?: AssistantMessage, hideThinkingBlock?: boolean, markdownTheme?: MarkdownTheme, hiddenThinkingLabel?: string, outputPad?: number, markdownTransformers?: readonly MarkdownTransformer[]);
+    invalidate(): void;
+    setHideThinkingBlock(hide: boolean): void;
+    setHiddenThinkingLabel(label: string): void;
+    setOutputPad(padding: number): void;
+    render(width: number): string[];
+    updateContent(message: AssistantMessage, isStreaming?: boolean): void;
+}

package/dist/vendor/engine/runtime/coding-agent/modes/interactive/components/assistant-message.js

@@ -0,0 +1,157 @@
+import { AndorraContainer, AndorraMarkdown, AndorraMouseRegion, AndorraSpacer, AndorraText } from "../../../../tui/index.js";
+import { andorraGetMarkdownTheme, theme } from "../theme/theme.js";
+import { andorraCreateMarkdownTransform } from "./markdown-transform.js";
+const OSC133_ZONE_START = "\x1b]133;A\x07";
+const OSC133_ZONE_END = "\x1b]133;B\x07";
+const OSC133_ZONE_FINAL = "\x1b]133;C\x07";
+/**
+ * Component that renders a complete assistant message
+ */
+export class AndorraAssistantMessageComponent extends AndorraContainer {
+    contentContainer;
+    hideThinkingBlock;
+    markdownTheme;
+    hiddenThinkingLabel;
+    outputPad;
+    markdownTransformers;
+    lastMessage;
+    hasToolCalls = false;
+    isStreaming = false;
+    thinkingVisibilityOverrides = new Map();
+    constructor(message, hideThinkingBlock = false, markdownTheme = andorraGetMarkdownTheme(), hiddenThinkingLabel = "Thinking...", outputPad = 1, markdownTransformers = []) {
+        super();
+        this.hideThinkingBlock = hideThinkingBlock;
+        this.markdownTheme = markdownTheme;
+        this.hiddenThinkingLabel = hiddenThinkingLabel;
+        this.outputPad = outputPad;
+        this.markdownTransformers = markdownTransformers;
+        // Container for text/thinking content
+        this.contentContainer = new AndorraContainer();
+        this.addChild(this.contentContainer);
+        if (message) {
+            this.updateContent(message);
+        }
+    }
+    invalidate() {
+        super.invalidate();
+        if (this.lastMessage) {
+            this.updateContent(this.lastMessage);
+        }
+    }
+    setHideThinkingBlock(hide) {
+        this.hideThinkingBlock = hide;
+        this.thinkingVisibilityOverrides.clear();
+        if (this.lastMessage) {
+            this.updateContent(this.lastMessage);
+        }
+    }
+    setHiddenThinkingLabel(label) {
+        this.hiddenThinkingLabel = label;
+        if (this.lastMessage) {
+            this.updateContent(this.lastMessage);
+        }
+    }
+    setOutputPad(padding) {
+        this.outputPad = padding;
+        if (this.lastMessage) {
+            this.updateContent(this.lastMessage);
+        }
+    }
+    render(width) {
+        const lines = super.render(width);
+        if (this.hasToolCalls || lines.length === 0) {
+            return lines;
+        }
+        lines[0] = OSC133_ZONE_START + lines[0];
+        lines[lines.length - 1] = OSC133_ZONE_END + OSC133_ZONE_FINAL + lines[lines.length - 1];
+        return lines;
+    }
+    updateContent(message, isStreaming = this.isStreaming) {
+        this.lastMessage = message;
+        this.isStreaming = isStreaming;
+        // Clear content container
+        this.contentContainer.clear();
+        const hasVisibleContent = message.content.some((c) => (c.type === "text" && c.text.trim()) || (c.type === "thinking" && c.thinking.trim()));
+        if (hasVisibleContent) {
+            this.contentContainer.addChild(new AndorraSpacer(1));
+        }
+        // Render content in order
+        let thinkingRunIndex = 0;
+        for (let i = 0; i < message.content.length; i++) {
+            const content = message.content[i];
+            if (content.type === "text" && content.text.trim()) {
+                // Assistant text messages with no background - trim the text
+                // Set paddingY=0 to avoid extra spacing before tool executions
+                this.contentContainer.addChild(new AndorraMarkdown(content.text.trim(), this.outputPad, 0, this.markdownTheme, undefined, {
+                    transform: andorraCreateMarkdownTransform("assistant", this.isStreaming, this.markdownTransformers),
+                }));
+            }
+            else if (content.type === "thinking") {
+                const thinkingBlocks = [];
+                for (; i < message.content.length; i++) {
+                    const thinkingContent = message.content[i];
+                    if (thinkingContent.type !== "thinking") {
+                        break;
+                    }
+                    const thinking = thinkingContent.thinking.trim();
+                    if (thinking) {
+                        thinkingBlocks.push(thinking);
+                    }
+                }
+                i--;
+                if (thinkingBlocks.length === 0) {
+                    continue;
+                }
+                // Add spacing only when another visible assistant content block follows.
+                // This avoids a superfluous blank line before separately-rendered tool execution blocks.
+                const hasVisibleContentAfter = message.content
+                    .slice(i + 1)
+                    .some((c) => (c.type === "text" && c.text.trim()) || (c.type === "thinking" && c.thinking.trim()));
+                const runIndex = thinkingRunIndex++;
+                const hidden = this.thinkingVisibilityOverrides.get(runIndex) ?? this.hideThinkingBlock;
+                const thinkingComponent = hidden
+                    ? new AndorraText(theme.italic(theme.fg("thinkingText", this.hiddenThinkingLabel)), this.outputPad, 0)
+                    : new AndorraMarkdown(thinkingBlocks.join("\n\n"), this.outputPad, 0, this.markdownTheme, {
+                        color: (text) => theme.fg("thinkingText", text),
+                        italic: true,
+                    }, {
+                        transform: andorraCreateMarkdownTransform("assistant-thinking", this.isStreaming, this.markdownTransformers),
+                    });
+                this.contentContainer.addChild(new AndorraMouseRegion(thinkingComponent, (event) => {
+                    if (event.type !== "click" || event.button !== "left")
+                        return undefined;
+                    this.thinkingVisibilityOverrides.set(runIndex, !hidden);
+                    if (this.lastMessage)
+                        this.updateContent(this.lastMessage);
+                    return { handled: true };
+                }));
+                if (hasVisibleContentAfter) {
+                    this.contentContainer.addChild(new AndorraSpacer(1));
+                }
+            }
+        }
+        // Check if incomplete/failed - show after partial content.
+        // For aborted/error tool calls, tool execution components show the error.
+        // Length stops can happen before a tool call is complete, so surface them here too.
+        const hasToolCalls = message.content.some((c) => c.type === "toolCall");
+        this.hasToolCalls = hasToolCalls;
+        if (message.stopReason === "length") {
+            this.contentContainer.addChild(new AndorraSpacer(1));
+            this.contentContainer.addChild(new AndorraText(theme.fg("error", "Response was truncated before completion."), this.outputPad, 0));
+        }
+        else if (!hasToolCalls) {
+            if (message.stopReason === "aborted") {
+                const abortMessage = message.errorMessage && message.errorMessage !== "Request was aborted"
+                    ? message.errorMessage
+                    : "Operation aborted";
+                this.contentContainer.addChild(new AndorraSpacer(1));
+                this.contentContainer.addChild(new AndorraText(theme.fg("error", abortMessage), this.outputPad, 0));
+            }
+            else if (message.stopReason === "error") {
+                const errorMsg = message.errorMessage || "Unknown error";
+                this.contentContainer.addChild(new AndorraSpacer(1));
+                this.contentContainer.addChild(new AndorraText(theme.fg("error", `Error: ${errorMsg}`), this.outputPad, 0));
+            }
+        }
+    }
+}

package/dist/vendor/engine/runtime/coding-agent/modes/interactive/components/bash-execution.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Component for displaying bash command execution with streaming output.
+ */
+import { AndorraContainer, type TUI } from "../../../../tui/index.js";
+import { type TruncationResult } from "../../../core/tools/truncate.js";
+export declare class AndorraBashExecutionComponent extends AndorraContainer {
+    private command;
+    private outputLines;
+    private status;
+    private exitCode;
+    private loader;
+    private truncationResult?;
+    private fullOutputPath?;
+    private expanded;
+    private contentContainer;
+    constructor(command: string, ui: TUI, excludeFromContext?: boolean);
+    /**
+     * Set whether the output is expanded (shows full output) or collapsed (preview only).
+     */
+    setExpanded(expanded: boolean): void;
+    invalidate(): void;
+    appendOutput(chunk: string): void;
+    setComplete(exitCode: number | undefined, cancelled: boolean, truncationResult?: TruncationResult, fullOutputPath?: string): void;
+    private updateDisplay;
+    /**
+     * Get the raw output for creating BashExecutionMessage.
+     */
+    getOutput(): string;
+    /**
+     * Get the command that was executed.
+     */
+    getCommand(): string;
+}