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

package/dist/src/pi/runtime-services.js

@@ -0,0 +1,356 @@
+import { logExtensionError } from "../shared/errors.js";
+import { formatRangeMention } from "../shared/format.js";
+import { hasDirectWorkspaceMatch } from "../shared/paths.js";
+import { IdeConnection, IdeConnectionTimeoutError } from "./connection.js";
+import { discoverIdeCandidates } from "./discovery.js";
+import { handleDiagnosticFixRequested } from "./diagnostics.js";
+import { discoverInstallCandidates, installIdeExtension, isAutoInstallEnabled, selectAutoInstallCandidate, } from "./install.js";
+import { resetReconnectState, scheduleReconnect, stopReconnectScheduling } from "./reconnect.js";
+import { containPiError } from "./safety.js";
+import { clearLatestSelection, setLatestSelection } from "./selection.js";
+import { clearIdeUi, updateIdeUi } from "./ui.js";
+import { startZedPolling, stopZedPolling } from "./zed.js";
+const INSTALL_RECONNECT_RETRY_MS = 1_500;
+const INSTALL_RECONNECT_TIMEOUT_MS = 15_000;
+let activePi;
+function formatConnectTimeoutMessage(error) {
+    return `${error.message}.`;
+}
+export async function startSession(pi, runtime, ctx) {
+    activePi = pi;
+    runtime.ctx = ctx;
+    runtime.cwd = ctx.cwd;
+    const generation = runtime.sessionGeneration;
+    stopZedPolling(runtime);
+    stopReconnectScheduling(runtime);
+    if (!runtime.enabled) {
+        runtime.connectionStatus = "disabled";
+        updateIdeUi(runtime, ctx);
+        return;
+    }
+    void maybeAutoInstallAndReconnect(runtime, ctx, generation);
+    await connectAutoWithZedFallback(runtime, ctx, generation);
+}
+export function shutdownSession(runtime, ctx) {
+    runtime.ctx = ctx;
+    stopZedPolling(runtime);
+    stopReconnectScheduling(runtime);
+    const connection = runtime.connection;
+    runtime.connection = undefined;
+    connection?.disconnect();
+    clearIdeUi(runtime, ctx);
+    runtime.ctx = undefined;
+    return Promise.resolve();
+}
+export async function refreshCandidates(runtime, ctx) {
+    runtime.ctx = ctx;
+    runtime.cwd = ctx.cwd;
+    runtime.candidates = await discoverIdeCandidates({ cwd: ctx.cwd });
+    return runtime.candidates;
+}
+export async function connectAuto(runtime, ctx, pi) {
+    if (pi)
+        activePi = pi;
+    await connectAutoWithZedFallback(runtime, ctx);
+}
+export async function connectCandidate(runtime, candidate, ctx, options = {}, pi) {
+    if (pi)
+        activePi = pi;
+    await connectCandidateInternal(runtime, candidate, ctx, options);
+}
+export function disconnect(runtime, ctx, disabled = false) {
+    runtime.ctx = ctx;
+    stopZedPolling(runtime);
+    stopReconnectScheduling(runtime);
+    const connection = runtime.connection;
+    runtime.connection = undefined;
+    connection?.disconnect();
+    resetReconnectState(runtime);
+    runtime.enabled = !disabled;
+    runtime.connectedServer = undefined;
+    runtime.connectionStatus = disabled ? "disabled" : "disconnected";
+    runtime.connectionMessage = disabled ? "IDE integration disabled." : "Disconnected.";
+    if (disabled) {
+        runtime.latestSelection = undefined;
+        runtime.latestSelectionKey = undefined;
+        runtime.turnSelection = undefined;
+        runtime.attachState = "idle";
+    }
+    updateIdeUi(runtime, ctx);
+    return Promise.resolve();
+}
+export async function installExtension(runtime, ctx) {
+    runtime.ctx = ctx;
+    runtime.cwd = ctx.cwd;
+    const candidates = await discoverInstallCandidates({ includeLowConfidence: true });
+    if (candidates.length === 0) {
+        ctx.ui.notify("No supported VS Code-family IDE CLI found. Install VS Code, Cursor, or Windsurf CLI first.", "warning");
+        return;
+    }
+    const candidate = await selectManualInstallCandidate(candidates, ctx);
+    if (!candidate)
+        return;
+    runtime.enabled = true;
+    if (!candidate.needsInstall) {
+        ctx.ui.notify(`${candidate.label} already has Pi x IDE ${candidate.installedVersion ?? candidate.targetVersion}.`, "info");
+        await connectAutoInternal(runtime, ctx);
+        return;
+    }
+    ctx.ui.notify(`${installActionLabel(candidate)} Pi x IDE extension for ${candidate.label}...`, "info");
+    const result = await installIdeExtension(candidate, runtime);
+    if (!result.success) {
+        ctx.ui.notify(`Failed to install Pi x IDE extension for ${candidate.label}: ${describeInstallError(result.error, result.stderr)}`, "warning");
+        return;
+    }
+    ctx.ui.notify(`Pi x IDE extension installed for ${candidate.label}. Trying to connect...`, "info");
+    const connected = await retryConnectAfterInstall(runtime, ctx, runtime.sessionGeneration);
+    if (!connected && runtime.enabled) {
+        ctx.ui.notify(`Pi x IDE extension installed for ${candidate.label}. If Pi does not connect automatically, reload the IDE window and run /ide auto.`, "warning");
+    }
+}
+async function maybeAutoInstallAndReconnect(runtime, ctx, generation) {
+    try {
+        if (!isAutoInstallEnabled(process.env, { projectDir: ctx.cwd ?? runtime.cwd }) ||
+            !isInstallSessionActive(runtime, generation)) {
+            return;
+        }
+        const candidates = await discoverInstallCandidates();
+        const candidate = selectAutoInstallCandidate(candidates);
+        if (!candidate)
+            return;
+        if (!isInstallSessionActive(runtime, generation))
+            return;
+        if (!candidate.needsInstall)
+            return;
+        notifyInstall(ctx, `Installing Pi x IDE extension for ${candidate.label}...`, "info");
+        const result = await installIdeExtension(candidate, runtime);
+        if (!isInstallSessionActive(runtime, generation))
+            return;
+        if (!result.success) {
+            notifyInstall(ctx, `Failed to install Pi x IDE extension for ${candidate.label}: ${describeInstallError(result.error, result.stderr)}`, "warning");
+            return;
+        }
+        notifyInstall(ctx, `Pi x IDE extension installed for ${candidate.label}. Trying to connect...`, "info");
+        const connected = await retryConnectAfterInstall(runtime, ctx, generation);
+        if (!isInstallSessionActive(runtime, generation))
+            return;
+        if (connected && runtime.connectionStatus === "connected") {
+            notifyInstall(ctx, `Pi x IDE extension installed for ${candidate.label}. Connected!`, "info");
+        }
+        else if (!connected) {
+            notifyInstall(ctx, `Pi x IDE extension installed for ${candidate.label}. If Pi does not connect automatically, reload the IDE window and run /ide.`, "warning");
+        }
+        else {
+            notifyInstall(ctx, `Pi x IDE extension installed for ${candidate.label}. Connection attempt completed. Run /ide to retry if needed.`, "warning");
+        }
+    }
+    catch (error) {
+        if (isInstallSessionActive(runtime, generation)) {
+            notifyInstall(ctx, `Failed to auto-install Pi x IDE extension: ${errorMessage(error)}`, "warning");
+        }
+    }
+}
+async function selectManualInstallCandidate(candidates, ctx) {
+    if (candidates.length === 1)
+        return candidates[0];
+    const labels = candidates.map((candidate, index) => `${index + 1}. ${formatInstallCandidate(candidate)}`);
+    const choice = await ctx.ui.select("Select IDE to install Pi x IDE", labels);
+    if (!choice)
+        return undefined;
+    return candidates[labels.indexOf(choice)];
+}
+async function retryConnectAfterInstall(runtime, ctx, generation) {
+    const deadline = Date.now() + INSTALL_RECONNECT_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        if (!isInstallSessionActive(runtime, generation))
+            return false;
+        await sleep(INSTALL_RECONNECT_RETRY_MS);
+        if (!isInstallSessionActive(runtime, generation))
+            return false;
+        const candidates = await refreshCandidates(runtime, ctx);
+        if (candidates.length === 0)
+            continue;
+        await connectAutoInternal(runtime, ctx);
+        return true;
+    }
+    return false;
+}
+function isInstallSessionActive(runtime, generation) {
+    return runtime.enabled && runtime.sessionGeneration === generation;
+}
+function formatInstallCandidate(candidate) {
+    const version = candidate.installedVersion ? `installed ${candidate.installedVersion}` : "not installed";
+    const status = candidate.reason === "current" ? "up to date" : `${installActionLabel(candidate).toLowerCase()} required`;
+    return `${candidate.label} — ${version}, target ${candidate.targetVersion}, ${status} (${candidate.cliPath})`;
+}
+function installActionLabel(candidate) {
+    if (candidate.reason === "outdated")
+        return "Updating";
+    if (candidate.reason === "unknown")
+        return "Installing or updating";
+    return "Installing";
+}
+function notifyInstall(ctx, message, level) {
+    try {
+        if (!ctx.hasUI)
+            return;
+        ctx.ui.notify(message, level);
+    }
+    catch (error) {
+        logExtensionError("IDE install notification", error);
+    }
+}
+function describeInstallError(error, stderr) {
+    const message = error || stderr.trim();
+    return message || "unknown error";
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function connectAutoWithZedFallback(runtime, ctx, generation = runtime.sessionGeneration, options = {}) {
+    await connectAutoInternal(runtime, ctx, options);
+    if (runtime.connectionStatus !== "connected") {
+        startZedPolling(runtime, ctx, { generation });
+    }
+}
+async function connectAutoInternal(runtime, ctx, options = {}) {
+    runtime.enabled = true;
+    const candidates = await refreshCandidates(runtime, ctx);
+    const candidate = candidates.find((entry) => isAutoConnectCandidate(entry, ctx.cwd));
+    if (!candidate) {
+        if (options.resetReconnectState !== false)
+            resetReconnectState(runtime);
+        runtime.connectionStatus = "disconnected";
+        runtime.connectionMessage =
+            candidates.length > 0
+                ? "No IDE lock file matches the current workspace. Use /ide to connect manually."
+                : "No matching IDE lock files found.";
+        runtime.currentCandidate = undefined;
+        runtime.connectedServer = undefined;
+        updateIdeUi(runtime, ctx);
+        return;
+    }
+    await connectCandidateInternal(runtime, candidate, ctx, options);
+}
+function isAutoConnectCandidate(candidate, cwd) {
+    return hasDirectWorkspaceMatch(candidate.lock.workspaceFolders, cwd);
+}
+async function connectCandidateInternal(runtime, candidate, ctx, options = {}) {
+    if (options.resetReconnectState !== false)
+        resetReconnectState(runtime);
+    runtime.ctx = ctx;
+    runtime.cwd = ctx.cwd;
+    runtime.enabled = true;
+    stopZedPolling(runtime);
+    stopReconnectScheduling(runtime);
+    const previous = runtime.connection;
+    runtime.connection = undefined;
+    previous?.disconnect();
+    runtime.currentCandidate = candidate;
+    runtime.connectedServer = undefined;
+    runtime.connectionStatus = "connecting";
+    runtime.connectionMessage = `Connecting to ${candidate.lock.name} at ${candidate.lock.host}:${candidate.lock.port}`;
+    updateIdeUi(runtime, ctx);
+    const generation = runtime.sessionGeneration;
+    const connectionRef = {};
+    const connection = new IdeConnection(candidate, ctx.cwd, createConnectionCallbacks(activePi, runtime, () => connectionRef.current, generation));
+    connectionRef.current = connection;
+    runtime.connection = connection;
+    try {
+        await connection.connect();
+        if (runtime.connection === connection && runtime.connectionStatus === "connecting") {
+            runtime.connectionStatus = "connected";
+            runtime.connectionMessage = undefined;
+            resetReconnectState(runtime);
+            updateIdeUi(runtime, ctx);
+        }
+    }
+    catch (error) {
+        if (runtime.connection === connection) {
+            runtime.connection = undefined;
+            runtime.connectionStatus = "error";
+            runtime.connectionMessage =
+                error instanceof IdeConnectionTimeoutError ? formatConnectTimeoutMessage(error) : errorMessage(error);
+            updateIdeUi(runtime, ctx);
+            if (!(error instanceof IdeConnectionTimeoutError))
+                scheduleIdeReconnect(runtime);
+        }
+    }
+}
+function createConnectionCallbacks(pi, runtime, getConnection, generation) {
+    return {
+        onConnected: (server) => {
+            if (!isCurrentConnection(runtime, getConnection(), generation))
+                return;
+            runtime.connectedServer = server;
+            runtime.connectionStatus = "connected";
+            runtime.connectionMessage = undefined;
+            resetReconnectState(runtime);
+            updateIdeUi(runtime);
+        },
+        onDisconnected: (reason) => {
+            if (!isCurrentConnection(runtime, getConnection(), generation))
+                return;
+            runtime.connection = undefined;
+            runtime.connectedServer = undefined;
+            runtime.connectionStatus = runtime.enabled ? "disconnected" : "disabled";
+            runtime.connectionMessage = reason;
+            updateIdeUi(runtime);
+            if (runtime.enabled)
+                scheduleIdeReconnect(runtime);
+        },
+        onSelectionChanged: (snapshot) => {
+            if (!isCurrentConnection(runtime, getConnection(), generation))
+                return;
+            setLatestSelection(runtime, snapshot);
+        },
+        onSelectionCleared: () => {
+            if (!isCurrentConnection(runtime, getConnection(), generation))
+                return;
+            clearLatestSelection(runtime);
+        },
+        onAtMentioned: (params) => {
+            if (!isCurrentConnection(runtime, getConnection(), generation))
+                return;
+            handleAtMentioned(runtime, params);
+        },
+        onDiagnosticFixRequested: (params) => {
+            if (!pi || !isCurrentConnection(runtime, getConnection(), generation))
+                return;
+            handleDiagnosticFixRequested(pi, runtime, params);
+        },
+        onError: (error) => {
+            if (!isCurrentConnection(runtime, getConnection(), generation))
+                return;
+            containPiError(runtime, "IDE connection error", error);
+        },
+    };
+}
+function isCurrentConnection(runtime, connection, generation = runtime.sessionGeneration) {
+    return runtime.sessionGeneration === generation && !!connection && runtime.connection === connection;
+}
+function scheduleIdeReconnect(runtime) {
+    scheduleReconnect(runtime, async (generation) => {
+        const ctx = runtime.ctx;
+        if (!ctx || !runtime.enabled || runtime.sessionGeneration !== generation)
+            return;
+        try {
+            await connectAutoWithZedFallback(runtime, ctx, runtime.sessionGeneration, { resetReconnectState: false });
+        }
+        catch (error) {
+            containPiError(runtime, "IDE reconnect", error);
+        }
+    });
+}
+function handleAtMentioned(runtime, params) {
+    setLatestSelection(runtime, params);
+    const ctx = runtime.ctx;
+    if (!ctx?.hasUI)
+        return;
+    const text = params.rangeText || formatRangeMention(params, { cwd: ctx.cwd });
+    ctx.ui.pasteToEditor(text + "\n");
+    ctx.ui.notify(`Attached ${text}`, "info");
+}

package/dist/src/pi/safety.js

@@ -0,0 +1,61 @@
+import { errorMessage, formatExtensionError, isStaleContextError, logExtensionError, safeRun, safeRunAsync, setExtensionErrorReporter, } from "../shared/errors.js";
+import { updateIdeUi } from "./ui.js";
+function deliverPiError(scope, error, ctx) {
+    try {
+        if (!ctx?.hasUI)
+            return false;
+        ctx.ui.notify(formatExtensionError(scope, error), "error");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function notifyPiError(scope, error, ctx) {
+    if (isStaleContextError(error))
+        return;
+    deliverPiError(scope, error, ctx);
+}
+export function flushPendingPiErrors(runtime) {
+    if (runtime.pendingExtensionErrors.length === 0)
+        return;
+    const pending = runtime.pendingExtensionErrors;
+    runtime.pendingExtensionErrors = [];
+    for (const item of pending) {
+        if (isStaleContextError(item.error))
+            continue;
+        if (!deliverPiError(item.scope, item.error, runtime.ctx)) {
+            runtime.pendingExtensionErrors.push(item);
+        }
+    }
+}
+export function bindPiUiContext(runtime, ctx) {
+    runtime.ctx = ctx;
+    flushPendingPiErrors(runtime);
+}
+function reportPiExtensionError(runtime, scope, error) {
+    if (isStaleContextError(error))
+        return;
+    if (deliverPiError(scope, error, runtime.ctx))
+        return;
+    runtime.pendingExtensionErrors.push({ scope, error });
+}
+export function installPiErrorReporter(runtime) {
+    setExtensionErrorReporter((scope, error) => {
+        reportPiExtensionError(runtime, scope, error);
+    });
+}
+export function containPiError(runtime, scope, error, ctx = runtime.ctx) {
+    if (ctx)
+        bindPiUiContext(runtime, ctx);
+    logExtensionError(scope, error);
+    runtime.connectionStatus = "error";
+    runtime.connectionMessage = `${scope}: ${errorMessage(error)}`;
+    safeRun(`${scope} update UI after error`, () => updateIdeUi(runtime, ctx ?? runtime.ctx));
+}
+export function runPiBoundary(scope, runtime, action, ctx) {
+    return safeRun(scope, action, (error) => containPiError(runtime, scope, error, ctx));
+}
+export async function runPiBoundaryAsync(scope, runtime, action, ctx) {
+    return safeRunAsync(scope, action, (error) => containPiError(runtime, scope, error, ctx));
+}

package/dist/src/pi/selection.js

@@ -0,0 +1,18 @@
+import { snapshotKey } from "../shared/format.js";
+import { updateIdeUi } from "./ui.js";
+export function setLatestSelection(runtime, snapshot, ctx) {
+    const key = snapshotKey(snapshot);
+    runtime.latestSelection = snapshot;
+    if (runtime.latestSelectionKey !== key) {
+        runtime.latestSelectionKey = key;
+        runtime.attachState = "pending";
+    }
+    updateIdeUi(runtime, ctx);
+}
+export function clearLatestSelection(runtime, ctx) {
+    runtime.latestSelection = undefined;
+    runtime.latestSelectionKey = undefined;
+    runtime.turnSelection = undefined;
+    runtime.attachState = "idle";
+    updateIdeUi(runtime, ctx);
+}

package/dist/src/pi/state.js

@@ -0,0 +1,13 @@
+export function createRuntime() {
+    return {
+        enabled: true,
+        candidates: [],
+        connectionStatus: "idle",
+        attachState: "idle",
+        reconnectAttempts: 0,
+        installingIdeIds: new Set(),
+        sessionGeneration: 0,
+        sessionStarting: false,
+        pendingExtensionErrors: [],
+    };
+}