@saifymatteo/pi-x-ide 0.0.0-stage → 1.20.2

package/dist/src/pi/ui.js

@@ -0,0 +1,304 @@
+import { isStaleContextError, logExtensionError } from "../shared/errors.js";
+import { describeRanges } from "../shared/format.js";
+import { basename } from "node:path";
+import { EXT_CONFIG_NAME, readPiConfigStatusDisplay } from "../shared/config.js";
+import { toRelativeDisplayPath } from "../shared/paths.js";
+import { truncateToWidth, visibleWidth } from "../shared/display-width.js";
+const IDE_ICON = "⧉";
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const SPINNER_INTERVAL_MS = 90;
+const PI_THEME_KEYS = [
+    Symbol.for("@earendil-works/pi-coding-agent:theme"),
+    Symbol.for("@mariozechner/pi-coding-agent:theme"),
+];
+const statuslineSpinner = { frame: 0 };
+function getActiveUiContext(ctx) {
+    if (!ctx)
+        return undefined;
+    try {
+        if (!ctx.hasUI)
+            return undefined;
+        return { cwd: ctx.cwd, ui: ctx.ui };
+    }
+    catch (error) {
+        if (!isStaleContextError(error))
+            logExtensionError("read active Pi UI context", error);
+        return undefined;
+    }
+}
+function runReportingUiFailure(scope, action) {
+    try {
+        action();
+    }
+    catch (error) {
+        logExtensionError(scope, error);
+    }
+}
+export function updateIdeUi(runtime, ctx = runtime.ctx, statusDisplay) {
+    const uiContext = getActiveUiContext(ctx);
+    if (!uiContext)
+        return;
+    const display = statusDisplay ??
+        readPiConfigStatusDisplay({
+            projectDir: ctx?.cwd ?? runtime.cwd,
+        });
+    if (display === "statusline") {
+        clearWidget(uiContext);
+        updateStatusline(runtime, uiContext);
+        return;
+    }
+    stopStatuslineSpinner();
+    clearStatusline(uiContext);
+    updateWidget(runtime, uiContext);
+}
+export function clearIdeUi(runtime, ctx = runtime.ctx) {
+    const uiContext = getActiveUiContext(ctx);
+    stopStatuslineSpinner();
+    if (!uiContext)
+        return;
+    clearWidget(uiContext);
+    clearStatusline(uiContext);
+}
+function updateWidget(runtime, uiContext) {
+    runReportingUiFailure("update IDE UI widget", () => uiContext.ui.setWidget(EXT_CONFIG_NAME, (tui, theme) => {
+        let frame = 0;
+        let timer;
+        const animate = (active) => {
+            if (active && !timer) {
+                timer = setInterval(() => {
+                    try {
+                        frame = (frame + 1) % SPINNER_FRAMES.length;
+                        tui.requestRender();
+                    }
+                    catch (error) {
+                        logExtensionError("animate IDE UI widget", error);
+                        if (timer) {
+                            clearInterval(timer);
+                            timer = undefined;
+                        }
+                    }
+                }, SPINNER_INTERVAL_MS);
+                timer.unref?.();
+            }
+            else if (!active && timer) {
+                clearInterval(timer);
+                timer = undefined;
+            }
+        };
+        return {
+            render(width) {
+                try {
+                    const connecting = runtime.enabled && runtime.connectionStatus === "connecting";
+                    animate(connecting);
+                    const segments = buildStatusSegments(runtime, SPINNER_FRAMES[frame]);
+                    if (segments.length === 0 || width <= 0)
+                        return [];
+                    const visible = truncateSegments(segments, width);
+                    const plainWidth = visible.reduce((sum, segment) => sum + visibleWidth(segment.text), 0);
+                    const pad = " ".repeat(Math.max(0, width - plainWidth));
+                    return [pad + visible.map((segment) => theme.fg(segment.color, segment.text)).join("")];
+                }
+                catch (error) {
+                    logExtensionError("render IDE UI widget", error);
+                    animate(false);
+                    return [];
+                }
+            },
+            invalidate() { },
+            dispose() {
+                animate(false);
+            },
+        };
+    }, { placement: "aboveEditor" }));
+}
+function updateStatusline(runtime, uiContext) {
+    statuslineSpinner.runtime = runtime;
+    statuslineSpinner.ui = uiContext;
+    const connecting = runtime.enabled && runtime.connectionStatus === "connecting";
+    if (connecting) {
+        startStatuslineSpinner();
+    }
+    else {
+        stopStatuslineSpinner();
+    }
+    applyStatusline(runtime, uiContext, SPINNER_FRAMES[statuslineSpinner.frame]);
+}
+function applyStatusline(runtime, uiContext, spinnerFrame) {
+    runReportingUiFailure("update IDE statusline", () => {
+        const text = buildStatusText(runtime, spinnerFrame, getThemeColorizer());
+        uiContext.ui.setStatus(EXT_CONFIG_NAME, text);
+    });
+}
+function startStatuslineSpinner() {
+    if (statuslineSpinner.timer)
+        return;
+    statuslineSpinner.timer = setInterval(() => {
+        try {
+            statuslineSpinner.frame = (statuslineSpinner.frame + 1) % SPINNER_FRAMES.length;
+            const runtime = statuslineSpinner.runtime;
+            const ui = statuslineSpinner.ui;
+            if (!runtime || !ui)
+                return;
+            if (!(runtime.enabled && runtime.connectionStatus === "connecting")) {
+                stopStatuslineSpinner();
+                applyStatusline(runtime, ui, SPINNER_FRAMES[statuslineSpinner.frame]);
+                return;
+            }
+            applyStatusline(runtime, ui, SPINNER_FRAMES[statuslineSpinner.frame]);
+        }
+        catch (error) {
+            logExtensionError("animate IDE statusline", error);
+            stopStatuslineSpinner();
+        }
+    }, SPINNER_INTERVAL_MS);
+    statuslineSpinner.timer.unref?.();
+}
+function stopStatuslineSpinner() {
+    if (!statuslineSpinner.timer)
+        return;
+    clearInterval(statuslineSpinner.timer);
+    statuslineSpinner.timer = undefined;
+}
+function clearWidget(uiContext) {
+    runReportingUiFailure("clear IDE UI widget", () => uiContext.ui.setWidget(EXT_CONFIG_NAME, undefined));
+}
+function clearStatusline(uiContext) {
+    runReportingUiFailure("clear IDE statusline", () => uiContext.ui.setStatus(EXT_CONFIG_NAME, undefined));
+}
+function truncateSegments(segments, width) {
+    const total = segments.reduce((sum, segment) => sum + visibleWidth(segment.text), 0);
+    if (total <= width)
+        return segments;
+    const fallbackColor = segments[0]?.color ?? "dim";
+    if (width <= 3)
+        return [{ text: ".".repeat(width), color: fallbackColor }];
+    const shrinkIndex = segments.findIndex((segment) => segment.shrink);
+    if (shrinkIndex >= 0) {
+        const shrinkSegment = segments[shrinkIndex];
+        const shrinkWidth = visibleWidth(shrinkSegment.text);
+        const reservedWidth = total - shrinkWidth;
+        const room = width - reservedWidth;
+        if (room > 0) {
+            const preserved = segments.map((segment, index) => index === shrinkIndex ? { ...segment, text: truncateToWidth(segment.text, room) } : segment);
+            const preservedWidth = preserved.reduce((sum, segment) => sum + visibleWidth(segment.text), 0);
+            if (preservedWidth <= width)
+                return preserved;
+        }
+    }
+    const ellipsis = "...";
+    const limit = width - visibleWidth(ellipsis);
+    const visible = [];
+    let used = 0;
+    for (const segment of segments) {
+        if (used >= limit)
+            break;
+        const room = limit - used;
+        const segmentWidth = visibleWidth(segment.text);
+        if (segmentWidth <= room) {
+            visible.push(segment);
+            used += segmentWidth;
+        }
+        else {
+            const text = truncateToWidth(segment.text, room, "");
+            if (text)
+                visible.push({ text, color: segment.color });
+            break;
+        }
+    }
+    visible.push({ text: ellipsis, color: visible[visible.length - 1]?.color ?? fallbackColor });
+    return visible;
+}
+export function buildStatusSegments(runtime, spinnerFrame = SPINNER_FRAMES[0]) {
+    if (!runtime.enabled)
+        return [];
+    switch (runtime.connectionStatus) {
+        case "connecting":
+            return [{ text: `${IDE_ICON} ${spinnerFrame}`, color: "dim" }];
+        case "error":
+            return [
+                { text: `${IDE_ICON} `, color: "dim" },
+                { text: "✕", color: "error" },
+            ];
+        case "connected":
+            return buildConnectedSegments(runtime);
+        default:
+            return [];
+    }
+}
+export function buildStatusText(runtime, spinnerFrame = SPINNER_FRAMES[0], colorize) {
+    const segments = buildStatusSegments(runtime, spinnerFrame);
+    if (segments.length === 0)
+        return undefined;
+    return formatStatusSegments(segments, colorize);
+}
+export function formatStatusSegments(segments, colorize) {
+    if (!colorize)
+        return segments.map((segment) => segment.text).join("");
+    return segments.map((segment) => colorize(segment.color, segment.text)).join("");
+}
+function getThemeColorizer() {
+    const activeTheme = getActivePiTheme();
+    if (!activeTheme)
+        return undefined;
+    return (color, text) => activeTheme.fg(color, text);
+}
+function getActivePiTheme() {
+    const globalStore = globalThis;
+    for (const key of PI_THEME_KEYS) {
+        const candidate = globalStore[key];
+        if (!isThemeLike(candidate))
+            continue;
+        return candidate;
+    }
+    return undefined;
+}
+function isThemeLike(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    return typeof value.fg === "function";
+}
+function buildConnectedSegments(runtime) {
+    const selection = runtime.latestSelection;
+    if (!selection)
+        return [{ text: `${IDE_ICON} ✓`, color: "dim" }];
+    const rel = basename(selection.filePath);
+    const range = describeRanges(selection.ranges);
+    const pending = runtime.attachState === "pending";
+    const marker = pending ? "⇡" : "✓";
+    const color = pending ? "success" : "dim";
+    const prefix = `${IDE_ICON} ${marker} `;
+    if (range === "open file")
+        return [{ text: `${prefix}${rel}`, color, shrink: true }];
+    return [
+        { text: prefix, color },
+        { text: rel, color, shrink: true },
+        { text: range, color },
+    ];
+}
+export function buildWidget(runtime, cwd) {
+    if (!runtime.enabled || runtime.connectionStatus === "disabled")
+        return undefined;
+    if (runtime.connectionStatus !== "connected" &&
+        runtime.connectionStatus !== "connecting" &&
+        runtime.connectionStatus !== "error") {
+        return undefined;
+    }
+    const lines = [];
+    const ide = runtime.connectedServer?.name ?? runtime.currentCandidate?.lock.name ?? "IDE";
+    lines.push(`IDE: ${ide} (${runtime.connectionStatus})`);
+    if (runtime.currentCandidate) {
+        lines.push(`Workspace: ${runtime.currentCandidate.workspaceFolder}`);
+    }
+    if (runtime.latestSelection) {
+        const selection = runtime.latestSelection;
+        lines.push(`File: ${toRelativeDisplayPath(selection.filePath, selection.workspaceFolder, cwd)}`);
+        lines.push(`Range: ${describeRanges(selection.ranges)}`);
+        lines.push(`Attach: ${runtime.attachState}`);
+        if (selection.receivedAt)
+            lines.push(`Updated: ${new Date(selection.receivedAt).toLocaleTimeString()}`);
+    }
+    else if (runtime.connectionMessage) {
+        lines.push(runtime.connectionMessage);
+    }
+    return lines;
+}