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

package/dist/src/pi/commands.js

@@ -0,0 +1,126 @@
+import { resolvePiConfigEnv } from "../shared/config.js";
+import { formatRangeMention } from "../shared/format.js";
+import { runPiBoundary, runPiBoundaryAsync } from "./safety.js";
+import { buildWidget, updateIdeUi } from "./ui.js";
+export const PI_X_IDE_ATTACH_SHORTCUT_ENV = "PI_X_IDE_ATTACH_SHORTCUT";
+export const DEFAULT_ATTACH_SHORTCUT = "ctrl+alt+k";
+const DISABLED_ATTACH_SHORTCUT_VALUES = new Set(["", "0", "false", "off", "none", "disabled"]);
+export function registerIdeCommand(pi, runtime, actions, options = {}) {
+    const attachShortcut = resolveAttachShortcut(options.env);
+    if (attachShortcut) {
+        pi.registerShortcut(attachShortcut, {
+            description: "Attach latest IDE selection to the prompt",
+            handler: (ctx) => {
+                runPiBoundary("IDE attach shortcut", runtime, () => {
+                    runtime.ctx = ctx;
+                    attachLatest(runtime, ctx);
+                }, ctx);
+            },
+        });
+    }
+    pi.registerCommand("ide", {
+        description: "Manage IDE connection and editor selection context",
+        getArgumentCompletions: (argumentPrefix) => {
+            const subcommands = [
+                { value: "status", label: "status", description: "Show IDE connection status" },
+                { value: "list", label: "list", description: "List available IDE connections" },
+                { value: "auto", label: "auto", description: "Auto-connect to the most recent IDE" },
+                { value: "off", label: "off", description: "Disable IDE integration" },
+                { value: "attach", label: "attach", description: "Attach latest IDE selection to the prompt" },
+                { value: "install", label: "install", description: "Install or update the IDE extension" },
+                { value: "settings", label: "settings", description: "Open IDE settings (Display, AutoInstall, ...)" },
+            ];
+            const filtered = subcommands.filter((s) => s.value.startsWith(argumentPrefix));
+            return filtered.length > 0 ? filtered : null;
+        },
+        handler: (args, ctx) => runPiBoundaryAsync("/ide command", runtime, async () => {
+            runtime.ctx = ctx;
+            const [subcommand] = args.trim().split(/\s+/, 1);
+            switch (subcommand || "") {
+                case "":
+                    await showPicker(runtime, actions, ctx);
+                    return;
+                case "status":
+                    showStatus(runtime, ctx);
+                    return;
+                case "list":
+                    await listCandidates(actions, ctx);
+                    return;
+                case "auto":
+                    runtime.enabled = true;
+                    await actions.connectAuto(ctx);
+                    return;
+                case "off":
+                    await actions.disconnect(ctx, true);
+                    return;
+                case "attach":
+                    attachLatest(runtime, ctx);
+                    return;
+                case "install":
+                    await actions.installExtension(ctx);
+                    return;
+                case "settings": {
+                    const { showIdeSettings } = await import("./config-ui.js");
+                    await showIdeSettings(runtime, ctx);
+                    return;
+                }
+                default:
+                    ctx.ui.notify("Usage: /ide [status|list|auto|off|attach|install|settings]", "warning");
+            }
+        }, ctx),
+    });
+}
+async function showPicker(runtime, actions, ctx) {
+    const candidates = await actions.refreshCandidates(ctx);
+    if (candidates.length === 0) {
+        ctx.ui.notify("No matching IDE connections found.", "warning");
+        return;
+    }
+    const labels = candidates.map((candidate, index) => `${index + 1}. ${candidate.lock.name} — ${candidate.workspaceFolder}`);
+    labels.push("Disable IDE integration");
+    const choice = await ctx.ui.select("Select IDE connection", labels);
+    if (!choice)
+        return;
+    if (choice === "Disable IDE integration") {
+        await actions.disconnect(ctx, true);
+        return;
+    }
+    const index = labels.indexOf(choice);
+    const candidate = candidates[index];
+    if (candidate) {
+        runtime.enabled = true;
+        await actions.connectCandidate(candidate, ctx);
+    }
+}
+function showStatus(runtime, ctx) {
+    const lines = buildWidget(runtime, ctx.cwd) ?? ["IDE: disconnected"];
+    ctx.ui.notify(lines.join("\n"), runtime.connectionStatus === "error" ? "error" : "info");
+}
+async function listCandidates(actions, ctx) {
+    const candidates = await actions.refreshCandidates(ctx);
+    if (candidates.length === 0) {
+        ctx.ui.notify("No matching IDE lock files found.", "info");
+        return;
+    }
+    ctx.ui.notify(candidates
+        .map((candidate, index) => `${index + 1}. ${candidate.lock.name} ${candidate.lock.host}:${candidate.lock.port}\n   ${candidate.workspaceFolder}\n   ${candidate.path}`)
+        .join("\n"), "info");
+}
+export function resolveAttachShortcut(env = process.env) {
+    const value = resolvePiConfigEnv(env)[PI_X_IDE_ATTACH_SHORTCUT_ENV] ?? DEFAULT_ATTACH_SHORTCUT;
+    const normalized = value.trim().toLowerCase();
+    if (DISABLED_ATTACH_SHORTCUT_VALUES.has(normalized))
+        return undefined;
+    return normalized;
+}
+function attachLatest(runtime, ctx) {
+    if (!runtime.latestSelection) {
+        ctx.ui.notify("No IDE selection is available.", "warning");
+        return;
+    }
+    const mention = formatRangeMention(runtime.latestSelection, { cwd: ctx.cwd });
+    ctx.ui.pasteToEditor(mention + "\n");
+    runtime.attachState = "pending";
+    updateIdeUi(runtime, ctx);
+    ctx.ui.notify(`Attached ${mention}`, "info");
+}

package/dist/src/pi/config-ui.js

@@ -0,0 +1,127 @@
+import { Container, Key, matchesKey, setKeybindings, SettingsList, Text, } from "@earendil-works/pi-tui";
+import { resolveIdeConfigSettings, writePiConfigSettings, } from "../shared/config.js";
+import { DEFAULT_STATUS_DISPLAY, STATUS_DISPLAY_VALUES } from "../shared/config-options.js";
+import { logExtensionError } from "../shared/errors.js";
+import { updateIdeUi } from "./ui.js";
+const DISPLAY_SETTING_ID = "display";
+const AUTO_INSTALL_SETTING_ID = "autoInstall";
+const BOOLEAN_SETTING_VALUES = ["true", "false"];
+const BORDER_CHAR = "\u2500";
+const SETTINGS_LIST_MAX_VISIBLE_ROWS = 10;
+const SETTINGS_LIST_EXTRA_ROWS = 2;
+export async function showStatusDisplayConfig(runtime, ctx, options = {}) {
+    return showIdeSettings(runtime, ctx, options);
+}
+export async function showIdeConfig(runtime, ctx, options = {}) {
+    return showIdeSettings(runtime, ctx, options);
+}
+export async function showIdeSettings(runtime, ctx, options = {}) {
+    const resolved = resolveIdeConfigSettings({ projectDir: ctx.cwd, home: options.home });
+    const result = await ctx.ui.custom((tui, theme, keybindings, done) => {
+        setKeybindings(keybindings);
+        const draft = {
+            display: resolved.settings.display ?? DEFAULT_STATUS_DISPLAY,
+            autoInstall: resolved.settings.autoInstall,
+        };
+        const items = [
+            {
+                id: DISPLAY_SETTING_ID,
+                label: "Display",
+                description: "IDE status placement: widget (above editor) or statusline (footer)",
+                currentValue: draft.display,
+                values: [...STATUS_DISPLAY_VALUES],
+            },
+            {
+                id: AUTO_INSTALL_SETTING_ID,
+                label: "AutoInstall",
+                description: "Auto-install VS Code-family extension on Pi startup (PI_X_IDE_AUTO_INSTALL)",
+                currentValue: draft.autoInstall ? "true" : "false",
+                values: [...BOOLEAN_SETTING_VALUES],
+            },
+        ];
+        const settingsList = new SettingsList(items, Math.min(items.length + SETTINGS_LIST_EXTRA_ROWS, SETTINGS_LIST_MAX_VISIBLE_ROWS), createSettingsListTheme(theme), (id, newValue) => {
+            if (id === DISPLAY_SETTING_ID && isStatusDisplayValue(newValue)) {
+                draft.display = newValue;
+                return;
+            }
+            if (id === AUTO_INSTALL_SETTING_ID && isBooleanSettingValue(newValue)) {
+                draft.autoInstall = newValue === "true";
+            }
+        }, () => done({ action: "cancel" }), { enableSearch: false });
+        const title = theme.fg("accent", theme.bold("Settings:"));
+        const help = theme.fg("dim", "↑↓ navigate · space cycle · ctrl+s save global · ctrl+p save project · esc cancel");
+        const container = new Container();
+        container.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+        container.addChild(new Text(title, 1, 0));
+        container.addChild(settingsList);
+        container.addChild(new Text(help, 1, 0));
+        container.addChild(new DynamicBorder((text) => theme.fg("accent", text)));
+        const saveCurrent = (scope) => {
+            done({
+                action: "save",
+                settings: { display: draft.display, autoInstall: draft.autoInstall },
+                scope,
+            });
+        };
+        return {
+            render: (width) => container.render(width),
+            invalidate: () => container.invalidate(),
+            handleInput: (data) => {
+                if (matchesKey(data, Key.ctrl("s"))) {
+                    saveCurrent("global");
+                    return;
+                }
+                if (matchesKey(data, Key.ctrl("p"))) {
+                    saveCurrent("project");
+                    return;
+                }
+                settingsList.handleInput(data);
+                tui.requestRender();
+            },
+        };
+    });
+    if (!result || result.action === "cancel")
+        return;
+    try {
+        const saved = writePiConfigSettings(result.settings, {
+            scope: result.scope,
+            projectDir: ctx.cwd,
+            home: options.home,
+        });
+        updateIdeUi(runtime, ctx, result.settings.display);
+        ctx.ui.notify([
+            `Saved to ${saved.scope}: ${saved.path}`,
+            `Display=${result.settings.display}`,
+            `AutoInstall=${result.settings.autoInstall}`,
+        ].join("\n"), "info");
+    }
+    catch (error) {
+        logExtensionError("save ide settings", error);
+    }
+}
+function isStatusDisplayValue(value) {
+    return STATUS_DISPLAY_VALUES.includes(value);
+}
+function isBooleanSettingValue(value) {
+    return BOOLEAN_SETTING_VALUES.includes(value);
+}
+function createSettingsListTheme(theme) {
+    return {
+        label: (text, selected) => (selected ? theme.fg("accent", text) : text),
+        value: (text, selected) => (selected ? theme.fg("accent", text) : theme.fg("muted", text)),
+        description: (text) => theme.fg("dim", text),
+        cursor: theme.fg("accent", "→ "),
+        hint: (text) => theme.fg("dim", text),
+    };
+}
+export class DynamicBorder {
+    color;
+    constructor(color) {
+        this.color = color;
+    }
+    invalidate() {
+    }
+    render(width) {
+        return [this.color(BORDER_CHAR.repeat(Math.max(0, width)))];
+    }
+}

package/dist/src/pi/connection.js

@@ -0,0 +1,237 @@
+import WebSocket from "ws";
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import { EXT_CONFIG_NAME } from "../shared/config.js";
+import { AUTH_HEADER, PROTOCOL_VERSION, } from "../shared/protocol.js";
+import { isAtMentionedParams, isDiagnosticFixRequestedParams, isSelectionChangedParams, isSelectionClearedParams, } from "../shared/schema.js";
+import { IdeConnectTimeoutError } from "../shared/effect-errors.js";
+import { toError, logExtensionError } from "../shared/errors.js";
+import { formatRangeMention } from "../shared/format.js";
+import { normalizeEditorSelectionSnapshotForHost } from "../shared/platform.js";
+import { decodeRawData } from "../shared/ws.js";
+import { resolveIdeHost } from "./ide-host.js";
+export const IDE_CONNECT_TIMEOUT_MS = 5_000;
+const IDE_CONNECT_HANDSHAKE_TIMEOUT_PADDING_MS = 1_000;
+export class IdeConnectionTimeoutError extends Error {
+    candidate;
+    host;
+    constructor(candidate, host = candidate.lock.host) {
+        super(`Timed out connecting to ${candidate.lock.name} at ${host}:${candidate.lock.port}`);
+        this.candidate = candidate;
+        this.host = host;
+        this.name = "IdeConnectionTimeoutError";
+    }
+}
+export class IdeConnection {
+    candidate;
+    cwd;
+    callbacks;
+    options;
+    socket;
+    nextId = 1;
+    closedByUser = false;
+    constructor(candidate, cwd, callbacks, options = {}) {
+        this.candidate = candidate;
+        this.cwd = cwd;
+        this.callbacks = callbacks;
+        this.options = options;
+    }
+    get isOpen() {
+        return this.socket?.readyState === WebSocket.OPEN;
+    }
+    async connect(timeoutMs = IDE_CONNECT_TIMEOUT_MS) {
+        const exit = await Effect.runPromiseExit(this.connectEffect(timeoutMs));
+        if (Exit.isSuccess(exit))
+            return;
+        const failure = Cause.squash(exit.cause);
+        if (isIdeConnectTimeoutError(failure)) {
+            throw new IdeConnectionTimeoutError(this.candidate, failure.host);
+        }
+        throw failure instanceof Error ? failure : toError(failure);
+    }
+    connectEffect(timeoutMs) {
+        return Effect.gen(this, function* () {
+            this.closedByUser = false;
+            const { lock } = this.candidate;
+            const resolvedHost = yield* Effect.tryPromise({
+                try: () => (this.options.resolveHost ?? resolveIdeHost)(lock),
+                catch: (cause) => toError(cause, "resolve host"),
+            });
+            const socket = new WebSocket(`ws://${resolvedHost}:${lock.port}`, {
+                handshakeTimeout: timeoutMs + IDE_CONNECT_HANDSHAKE_TIMEOUT_PADDING_MS,
+                headers: {
+                    [AUTH_HEADER]: lock.authToken,
+                },
+            });
+            this.socket = socket;
+            socket.on("message", (raw) => this.runSocketHandler("message", () => this.handleMessage(decodeRawData(raw))));
+            socket.on("close", (_code, reason) => {
+                this.runSocketHandler("close", () => {
+                    if (this.socket !== socket)
+                        return;
+                    this.socket = undefined;
+                    this.emitCallback("disconnected callback", () => this.callbacks.onDisconnected?.(reason.toString("utf8") || (this.closedByUser ? "closed" : "disconnected")));
+                });
+            });
+            socket.on("error", (error) => {
+                if (this.socket === socket)
+                    this.reportError("websocket error", error);
+            });
+            yield* Effect.async((resume) => {
+                let settled = false;
+                const finish = (result) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    cleanup();
+                    resume(result);
+                };
+                const timeout = setTimeout(() => {
+                    cleanup();
+                    if (this.socket === socket)
+                        this.socket = undefined;
+                    socket.terminate();
+                    if (settled)
+                        return;
+                    settled = true;
+                    resume(Effect.fail(new IdeConnectTimeoutError({
+                        name: this.candidate.lock.name,
+                        host: resolvedHost,
+                        port: lock.port,
+                    })));
+                }, timeoutMs);
+                const onOpen = () => {
+                    finish(Effect.succeed(undefined));
+                    this.sendInitialize();
+                };
+                const onError = (error) => {
+                    if (this.socket === socket)
+                        this.socket = undefined;
+                    finish(Effect.fail(error));
+                };
+                const cleanup = () => {
+                    clearTimeout(timeout);
+                    socket.off("open", onOpen);
+                    socket.off("error", onError);
+                };
+                socket.once("open", onOpen);
+                socket.once("error", onError);
+                return Effect.sync(cleanup);
+            });
+        });
+    }
+    disconnect() {
+        this.closedByUser = true;
+        this.socket?.close();
+        this.socket = undefined;
+    }
+    sendInitialize() {
+        this.socket?.send(JSON.stringify({
+            jsonrpc: "2.0",
+            id: this.nextId++,
+            method: "initialize",
+            params: {
+                protocolVersion: PROTOCOL_VERSION,
+                client: { name: EXT_CONFIG_NAME, version: "0.1.0" },
+                cwd: this.cwd,
+            },
+        }));
+    }
+    handleMessage(text) {
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            return;
+        }
+        if (isRpcResponse(parsed)) {
+            const server = getServerInfo(parsed);
+            if (server)
+                this.emitCallback("connected callback", () => this.callbacks.onConnected?.(server));
+            return;
+        }
+        if (!isNotification(parsed))
+            return;
+        if (parsed.method === "selection_changed" && isSelectionChangedParams(parsed.params)) {
+            const params = normalizeEditorSelectionSnapshotForHost(withReceivedAt(parsed.params), this.options.env);
+            this.emitCallback("selection changed callback", () => this.callbacks.onSelectionChanged?.(params));
+        }
+        else if (parsed.method === "selection_cleared" && isSelectionClearedParams(parsed.params)) {
+            const params = withReceivedAt(parsed.params);
+            this.emitCallback("selection cleared callback", () => this.callbacks.onSelectionCleared?.(params));
+        }
+        else if (parsed.method === "at_mentioned" && isAtMentionedParams(parsed.params)) {
+            const snapshot = normalizeEditorSelectionSnapshotForHost(withReceivedAt(parsed.params), this.options.env);
+            const params = { ...snapshot, rangeText: formatRangeMention(snapshot, { cwd: this.cwd, env: this.options.env }) };
+            this.emitCallback("at mentioned callback", () => this.callbacks.onAtMentioned?.(params));
+        }
+        else if (parsed.method === "diagnostic_fix_requested" && isDiagnosticFixRequestedParams(parsed.params)) {
+            const params = withReceivedAt(parsed.params);
+            this.emitCallback("diagnostic fix requested callback", () => this.callbacks.onDiagnosticFixRequested?.(params));
+        }
+    }
+    runSocketHandler(label, action) {
+        try {
+            action();
+        }
+        catch (error) {
+            this.reportError(`websocket ${label}`, error);
+        }
+    }
+    emitCallback(label, action) {
+        try {
+            action();
+        }
+        catch (error) {
+            this.reportError(label, error);
+        }
+    }
+    reportError(label, error) {
+        const reported = toError(error, label);
+        if (!this.callbacks.onError) {
+            logExtensionError(label, reported);
+            return;
+        }
+        try {
+            this.callbacks.onError(reported);
+        }
+        catch (callbackError) {
+            logExtensionError(`${label} onError callback`, callbackError);
+        }
+    }
+}
+function isIdeConnectTimeoutError(value) {
+    return value instanceof IdeConnectTimeoutError;
+}
+function withReceivedAt(params) {
+    return { ...params, receivedAt: params.receivedAt ?? Date.now() };
+}
+function isNotification(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        value.jsonrpc === "2.0" &&
+        typeof value.method === "string");
+}
+function isRpcResponse(value) {
+    return (typeof value === "object" && value !== null && value.jsonrpc === "2.0" && "id" in value);
+}
+function getServerInfo(response) {
+    const result = response.result;
+    if (!result || typeof result !== "object")
+        return undefined;
+    const server = result.server;
+    if (!server || typeof server !== "object")
+        return undefined;
+    const name = server.name;
+    if (typeof name !== "string")
+        return undefined;
+    const version = server.version;
+    const ide = server.ide;
+    return {
+        name,
+        version: typeof version === "string" ? version : undefined,
+        ide: typeof ide === "string" ? ide : undefined,
+    };
+}

package/dist/src/pi/context.js

@@ -0,0 +1,30 @@
+import { formatEditorContextMessage } from "../shared/format.js";
+import { DIAGNOSTIC_CONTEXT_MARKER } from "./diagnostics.js";
+import { runPiBoundary } from "./safety.js";
+import { updateIdeUi } from "./ui.js";
+export { clearLatestSelection, setLatestSelection } from "./selection.js";
+export function registerContextHandlers(pi, runtime) {
+    pi.on("before_agent_start", (event, ctx) => runPiBoundary("Pi before_agent_start", runtime, () => {
+        runtime.ctx = ctx;
+        if (!runtime.enabled || !runtime.latestSelection || runtime.attachState !== "pending")
+            return;
+        const snapshot = runtime.latestSelection;
+        runtime.attachState = "sent";
+        updateIdeUi(runtime, ctx);
+        if (promptContainsContextMarker(event.prompt, snapshot))
+            return;
+        return {
+            message: {
+                customType: IDE_CONTEXT_MESSAGE_TYPE,
+                content: formatEditorContextMessage(snapshot),
+                display: true,
+            },
+        };
+    }, ctx));
+}
+export const IDE_CONTEXT_MESSAGE_TYPE = "pi-x-ide/context";
+function promptContainsContextMarker(prompt, snapshot) {
+    return (prompt.includes(DIAGNOSTIC_CONTEXT_MARKER) ||
+        (prompt.includes("<system-reminder><selected-context>") &&
+            (prompt.includes(snapshot.filePath) || (!!snapshot.workspaceFolder && prompt.includes(snapshot.workspaceFolder)))));
+}