pi-x-ide 1.15.2 → 1.16.0

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [1.16.0](https://github.com/balaenis/pi-x-ide/compare/v1.15.2...v1.16.0) (2026-06-30)
+
+
+### Features
+
+* **pi:** render diagnostic-fix requests as custom TUI messages ([82d1821](https://github.com/balaenis/pi-x-ide/commit/82d18219cdfdfbb48689d6812db093396f229f4d))
+
 ## [1.15.2](https://github.com/balaenis/pi-x-ide/compare/v1.15.1...v1.15.2) (2026-06-29)
 
 

package/dist/src/pi/commands.js

@@ -1,22 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_ATTACH_SHORTCUT = exports.PI_X_IDE_ATTACH_SHORTCUT_ENV = void 0;
-exports.registerIdeCommand = registerIdeCommand;
-exports.resolveAttachShortcut = resolveAttachShortcut;
-const config_1 = require("../shared/config");
-const format_1 = require("../shared/format");
-const safety_1 = require("./safety");
-const ui_1 = require("./ui");
-exports.PI_X_IDE_ATTACH_SHORTCUT_ENV = "PI_X_IDE_ATTACH_SHORTCUT";
-exports.DEFAULT_ATTACH_SHORTCUT = "ctrl+alt+k";
+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"]);
-function registerIdeCommand(pi, runtime, actions, options = {}) {
+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) => {
-                (0, safety_1.runPiBoundary)("IDE attach shortcut", runtime, () => {
+                runPiBoundary("IDE attach shortcut", runtime, () => {
                     runtime.ctx = ctx;
                     attachLatest(runtime, ctx);
                 }, ctx);
@@ -37,7 +32,7 @@ function registerIdeCommand(pi, runtime, actions, options = {}) {
             const filtered = subcommands.filter((s) => s.value.startsWith(argumentPrefix));
             return filtered.length > 0 ? filtered : null;
         },
-        handler: (args, ctx) => (0, safety_1.runPiBoundaryAsync)("/ide command", runtime, async () => {
+        handler: (args, ctx) => runPiBoundaryAsync("/ide command", runtime, async () => {
             runtime.ctx = ctx;
             const [subcommand] = args.trim().split(/\s+/, 1);
             switch (subcommand || "") {
@@ -92,7 +87,7 @@ async function showPicker(runtime, actions, ctx) {
     }
 }
 function showStatus(runtime, ctx) {
-    const lines = (0, ui_1.buildWidget)(runtime, ctx.cwd) ?? ["IDE: disconnected"];
+    const lines = buildWidget(runtime, ctx.cwd) ?? ["IDE: disconnected"];
     ctx.ui.notify(lines.join("\n"), runtime.connectionStatus === "error" ? "error" : "info");
 }
 async function listCandidates(actions, ctx) {
@@ -105,8 +100,8 @@ async function listCandidates(actions, ctx) {
         .map((candidate, index) => `${index + 1}. ${candidate.lock.name} ${candidate.lock.host}:${candidate.lock.port}\n   ${candidate.workspaceFolder}\n   ${candidate.path}`)
         .join("\n"), "info");
 }
-function resolveAttachShortcut(env = process.env) {
-    const value = (0, config_1.resolvePiConfigEnv)(env)[exports.PI_X_IDE_ATTACH_SHORTCUT_ENV] ?? exports.DEFAULT_ATTACH_SHORTCUT;
+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;
@@ -117,9 +112,9 @@ function attachLatest(runtime, ctx) {
         ctx.ui.notify("No IDE selection is available.", "warning");
         return;
     }
-    const mention = (0, format_1.formatRangeMention)(runtime.latestSelection, { cwd: ctx.cwd });
+    const mention = formatRangeMention(runtime.latestSelection, { cwd: ctx.cwd });
     ctx.ui.pasteToEditor(mention);
     runtime.attachState = "pending";
-    (0, ui_1.updateIdeUi)(runtime, ctx);
+    updateIdeUi(runtime, ctx);
     ctx.ui.notify(`Attached ${mention}`, "info");
 }

package/dist/src/pi/connection.js

@@ -1,20 +1,14 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IdeConnection = exports.IdeConnectionTimeoutError = exports.IDE_CONNECT_TIMEOUT_MS = void 0;
-const ws_1 = __importDefault(require("ws"));
-const config_1 = require("../shared/config");
-const protocol_1 = require("../shared/protocol");
-const schema_1 = require("../shared/schema");
-const errors_1 = require("../shared/errors");
-const format_1 = require("../shared/format");
-const platform_1 = require("../shared/platform");
-const ws_2 = require("../shared/ws");
-const ide_host_1 = require("./ide-host");
-exports.IDE_CONNECT_TIMEOUT_MS = 5_000;
-class IdeConnectionTimeoutError extends Error {
+import WebSocket from "ws";
+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 { 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;
+export class IdeConnectionTimeoutError extends Error {
     candidate;
     host;
     constructor(candidate, host = candidate.lock.host) {
@@ -24,8 +18,7 @@ class IdeConnectionTimeoutError extends Error {
         this.name = "IdeConnectionTimeoutError";
     }
 }
-exports.IdeConnectionTimeoutError = IdeConnectionTimeoutError;
-class IdeConnection {
+export class IdeConnection {
     candidate;
     cwd;
     callbacks;
@@ -40,20 +33,20 @@ class IdeConnection {
         this.options = options;
     }
     get isOpen() {
-        return this.socket?.readyState === ws_1.default.OPEN;
+        return this.socket?.readyState === WebSocket.OPEN;
     }
-    async connect(timeoutMs = exports.IDE_CONNECT_TIMEOUT_MS) {
+    async connect(timeoutMs = IDE_CONNECT_TIMEOUT_MS) {
         this.closedByUser = false;
         const { lock } = this.candidate;
-        const resolvedHost = await (this.options.resolveHost ?? ide_host_1.resolveIdeHost)(lock);
-        const socket = new ws_1.default(`ws://${resolvedHost}:${lock.port}`, {
+        const resolvedHost = await (this.options.resolveHost ?? resolveIdeHost)(lock);
+        const socket = new WebSocket(`ws://${resolvedHost}:${lock.port}`, {
             handshakeTimeout: timeoutMs + 1_000,
             headers: {
-                [protocol_1.AUTH_HEADER]: lock.authToken,
+                [AUTH_HEADER]: lock.authToken,
             },
         });
         this.socket = socket;
-        socket.on("message", (raw) => this.runSocketHandler("message", () => this.handleMessage((0, ws_2.decodeRawData)(raw))));
+        socket.on("message", (raw) => this.runSocketHandler("message", () => this.handleMessage(decodeRawData(raw))));
         socket.on("close", (_code, reason) => {
             this.runSocketHandler("close", () => {
                 if (this.socket !== socket)
@@ -105,8 +98,8 @@ class IdeConnection {
             id: this.nextId++,
             method: "initialize",
             params: {
-                protocolVersion: protocol_1.PROTOCOL_VERSION,
-                client: { name: config_1.EXT_CONFIG_NAME, version: "0.1.0" },
+                protocolVersion: PROTOCOL_VERSION,
+                client: { name: EXT_CONFIG_NAME, version: "0.1.0" },
                 cwd: this.cwd,
             },
         }));
@@ -127,20 +120,20 @@ class IdeConnection {
         }
         if (!isNotification(parsed))
             return;
-        if (parsed.method === "selection_changed" && (0, schema_1.isSelectionChangedParams)(parsed.params)) {
-            const params = (0, platform_1.normalizeEditorSelectionSnapshotForHost)(withReceivedAt(parsed.params), this.options.env);
+        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" && (0, schema_1.isSelectionClearedParams)(parsed.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" && (0, schema_1.isAtMentionedParams)(parsed.params)) {
-            const snapshot = (0, platform_1.normalizeEditorSelectionSnapshotForHost)(withReceivedAt(parsed.params), this.options.env);
-            const params = { ...snapshot, rangeText: (0, format_1.formatRangeMention)(snapshot, { cwd: this.cwd, env: this.options.env }) };
+        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" && (0, schema_1.isDiagnosticFixRequestedParams)(parsed.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));
         }
@@ -162,20 +155,19 @@ class IdeConnection {
         }
     }
     reportError(label, error) {
-        const reported = (0, errors_1.toError)(error, label);
+        const reported = toError(error, label);
         if (!this.callbacks.onError) {
-            (0, errors_1.logExtensionError)(label, reported);
+            logExtensionError(label, reported);
             return;
         }
         try {
             this.callbacks.onError(reported);
         }
         catch (callbackError) {
-            (0, errors_1.logExtensionError)(`${label} onError callback`, callbackError);
+            logExtensionError(`${label} onError callback`, callbackError);
         }
     }
 }
-exports.IdeConnection = IdeConnection;
 function withReceivedAt(params) {
     return { ...params, receivedAt: params.receivedAt ?? Date.now() };
 }

package/dist/src/pi/context.js

@@ -1,14 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerContextHandlers = registerContextHandlers;
-exports.setLatestSelection = setLatestSelection;
-exports.clearLatestSelection = clearLatestSelection;
-const format_1 = require("../shared/format");
-const diagnostics_1 = require("./diagnostics");
-const safety_1 = require("./safety");
-const ui_1 = require("./ui");
-function registerContextHandlers(pi, runtime) {
-    pi.on("before_agent_start", (_event, ctx) => (0, safety_1.runPiBoundary)("Pi before_agent_start", runtime, () => {
+import { formatEditorContext, snapshotKey, SYSTEM_REMINDER_TAG, SELECTED_CONTEXT_MARKER } from "../shared/format.js";
+import { DIAGNOSTIC_CONTEXT_MARKER } from "./diagnostics.js";
+import { runPiBoundary } from "./safety.js";
+import { updateIdeUi } from "./ui.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)
             return;
@@ -18,7 +13,7 @@ function registerContextHandlers(pi, runtime) {
             return;
         runtime.turnSelection = runtime.latestSelection;
     }, ctx));
-    pi.on("message_end", (event, ctx) => (0, safety_1.runPiBoundary)("Pi message_end", runtime, () => {
+    pi.on("message_end", (event, ctx) => runPiBoundary("Pi message_end", runtime, () => {
         runtime.ctx = ctx;
         if (!runtime.enabled || !runtime.turnSelection)
             return;
@@ -28,29 +23,29 @@ function registerContextHandlers(pi, runtime) {
             runtime.turnSelection = undefined;
             return;
         }
-        const text = `${(0, format_1.formatEditorContext)(runtime.turnSelection)}\n`;
+        const text = `${formatEditorContext(runtime.turnSelection)}\n`;
         const message = mergeIntoUserMessage(event.message, text);
         runtime.attachState = "sent";
         runtime.turnSelection = undefined;
-        (0, ui_1.updateIdeUi)(runtime, ctx);
+        updateIdeUi(runtime, ctx);
         return { message };
     }, ctx));
 }
-function setLatestSelection(runtime, snapshot, ctx) {
-    const key = (0, format_1.snapshotKey)(snapshot);
+export function setLatestSelection(runtime, snapshot, ctx) {
+    const key = snapshotKey(snapshot);
     runtime.latestSelection = snapshot;
     if (runtime.latestSelectionKey !== key) {
         runtime.latestSelectionKey = key;
         runtime.attachState = "pending";
     }
-    (0, ui_1.updateIdeUi)(runtime, ctx);
+    updateIdeUi(runtime, ctx);
 }
-function clearLatestSelection(runtime, ctx) {
+export function clearLatestSelection(runtime, ctx) {
     runtime.latestSelection = undefined;
     runtime.latestSelectionKey = undefined;
     runtime.turnSelection = undefined;
     runtime.attachState = "idle";
-    (0, ui_1.updateIdeUi)(runtime, ctx);
+    updateIdeUi(runtime, ctx);
 }
 function mergeIntoUserMessage(message, text) {
     return {
@@ -63,6 +58,6 @@ function normalizeUserContent(content) {
 }
 function messageContainsMarker(message) {
     const serialized = JSON.stringify(message);
-    return (serialized.includes(`<${format_1.SYSTEM_REMINDER_TAG}><${format_1.SELECTED_CONTEXT_MARKER}>`) ||
-        serialized.includes(diagnostics_1.DIAGNOSTIC_CONTEXT_MARKER));
+    return (serialized.includes(`<${SYSTEM_REMINDER_TAG}><${SELECTED_CONTEXT_MARKER}>`) ||
+        serialized.includes(DIAGNOSTIC_CONTEXT_MARKER));
 }

package/dist/src/pi/diagnostic-renderer.js

@@ -0,0 +1,71 @@
+import { Box, Text } from "@earendil-works/pi-tui";
+import { toRelativeDisplayPath } from "../shared/paths.js";
+import { formatDiagnosticCode, formatRange } from "./diagnostics.js";
+export const DIAGNOSTIC_FIX_CUSTOM_TYPE = "pi-x-ide/diagnostic-fix";
+export function registerDiagnosticRenderer(pi) {
+    pi.registerMessageRenderer(DIAGNOSTIC_FIX_CUSTOM_TYPE, (message, { expanded }, theme) => {
+        const details = message.details;
+        if (!details)
+            return undefined;
+        return buildComponent(details, theme, expanded);
+    });
+}
+function buildComponent(details, theme, expanded) {
+    const box = new Box(1, 1, (t) => theme.bg("customMessageBg", t));
+    box.addChild(new Text(buildText(details, theme, expanded), 0, 0));
+    return box;
+}
+function buildText(details, theme, expanded) {
+    const severityColor = pickSeverityColor(details.diagnostics);
+    const label = theme.fg(severityColor, theme.bold("[DIAGNOSTIC]"));
+    const sourceLabel = describeSource(details.source);
+    const relPath = toRelativeDisplayPath(details.filePath, details.workspaceFolder, details.cwd);
+    const location = theme.fg("dim", `${relPath}:${formatRange(details.triggerRange)}`);
+    const count = details.diagnostics.length;
+    const noun = count === 1 ? "diagnostic" : "diagnostics";
+    const header = `${label} Fix ${count} ${noun} from ${sourceLabel} — ${location}`;
+    if (!expanded) {
+        return `${header}\n${theme.fg("dim", "ctrl+o to expand")}`;
+    }
+    const lines = [header];
+    for (const [index, diagnostic] of details.diagnostics.entries()) {
+        lines.push("");
+        lines.push(formatDiagnostic(diagnostic, index, details, theme));
+    }
+    return lines.join("\n");
+}
+function formatDiagnostic(diagnostic, index, details, theme) {
+    const color = diagnostic.severity === "error" ? "error" : "warning";
+    const headerText = `${diagnostic.severity.toUpperCase()} #${index + 1}`;
+    const lines = [`${theme.fg(color, headerText)} ${theme.fg("dim", formatRange(diagnostic.range))}`];
+    if (diagnostic.code !== undefined) {
+        lines.push(theme.fg("dim", `  code: ${formatDiagnosticCode(diagnostic.code)}`));
+    }
+    if (diagnostic.source) {
+        lines.push(theme.fg("dim", `  source: ${diagnostic.source}`));
+    }
+    lines.push(`  ${diagnostic.message}`);
+    if (diagnostic.contextLines.length > 0) {
+        for (const contextLine of diagnostic.contextLines) {
+            const marker = contextLine.isPrimary ? theme.fg(color, ">") : " ";
+            const lineNumber = theme.fg("dim", `${contextLine.line + 1}:`.padStart(4, " "));
+            lines.push(`  ${marker} ${lineNumber} ${contextLine.text}`);
+        }
+    }
+    if (diagnostic.relatedInformation && diagnostic.relatedInformation.length > 0) {
+        lines.push(theme.fg("dim", "  related:"));
+        for (const related of diagnostic.relatedInformation) {
+            const relatedPath = toRelativeDisplayPath(related.filePath, details.workspaceFolder, details.cwd);
+            lines.push(theme.fg("dim", `    ${relatedPath} ${formatRange(related.range)}: ${related.message}`));
+        }
+    }
+    return lines.join("\n");
+}
+function pickSeverityColor(diagnostics) {
+    return diagnostics.some((diagnostic) => diagnostic.severity === "error") ? "error" : "warning";
+}
+function describeSource(source) {
+    if (source === "vscode")
+        return "VS Code";
+    return source;
+}

package/dist/src/pi/diagnostics.js

@@ -1,13 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DIAGNOSTIC_CONTEXT_MARKER = void 0;
-exports.buildDiagnosticFixPrompt = buildDiagnosticFixPrompt;
-exports.buildDiagnosticContextMessage = buildDiagnosticContextMessage;
-exports.formatDiagnosticContext = formatDiagnosticContext;
-exports.handleDiagnosticFixRequested = handleDiagnosticFixRequested;
-const config_1 = require("../shared/config");
-exports.DIAGNOSTIC_CONTEXT_MARKER = "pi-x-ide/diagnostic-context";
-function buildDiagnosticFixPrompt(params, options = {}) {
+import { readPiConfigFixPrompt } from "../shared/config.js";
+import { DIAGNOSTIC_FIX_CUSTOM_TYPE } from "./diagnostic-renderer.js";
+export const DIAGNOSTIC_CONTEXT_MARKER = "pi-x-ide/diagnostic-context";
+export function buildDiagnosticFixPrompt(params, options = {}) {
     const context = buildDiagnosticContextMessage(params);
     const template = options.fixPrompt;
     if (!template) {
@@ -20,13 +14,13 @@ ${context}`;
     return `${template}
 ${context}`;
 }
-function buildDiagnosticContextMessage(params) {
-    return `<!-- ${exports.DIAGNOSTIC_CONTEXT_MARKER} -->
+export function buildDiagnosticContextMessage(params) {
+    return `<!-- ${DIAGNOSTIC_CONTEXT_MARKER} -->
 ${formatDiagnosticContext(params)}
-<!-- ${exports.DIAGNOSTIC_CONTEXT_MARKER} -->
+<!-- ${DIAGNOSTIC_CONTEXT_MARKER} -->
 `;
 }
-function formatDiagnosticContext(params) {
+export function formatDiagnosticContext(params) {
     const filePath = params.filePath;
     const lines = [`File: ${filePath}`, `Source: ${params.source}`];
     if (params.documentVersion !== undefined)
@@ -61,7 +55,7 @@ function formatDiagnosticContext(params) {
     }
     return lines.join("\n");
 }
-function handleDiagnosticFixRequested(pi, runtime, params) {
+export function handleDiagnosticFixRequested(pi, runtime, params) {
     const ctx = runtime.ctx;
     if (!ctx)
         return;
@@ -72,25 +66,34 @@ function handleDiagnosticFixRequested(pi, runtime, params) {
         ctx.ui.notify("VS Code diagnostic context added to input.", "info");
         return;
     }
-    const fixPrompt = (0, config_1.readPiConfigFixPrompt)();
+    const fixPrompt = readPiConfigFixPrompt();
     const prompt = buildDiagnosticFixPrompt(params, { fixPrompt });
-    if (ctx.isIdle()) {
-        pi.sendUserMessage(prompt);
-        return;
-    }
-    pi.sendUserMessage(prompt, { deliverAs: "followUp" });
-    if (ctx.hasUI)
+    const details = {
+        source: params.source,
+        filePath: params.filePath,
+        workspaceFolder: params.workspaceFolder,
+        triggerRange: params.triggerRange,
+        diagnostics: params.diagnostics,
+        cwd: ctx.cwd,
+    };
+    pi.sendMessage({
+        customType: DIAGNOSTIC_FIX_CUSTOM_TYPE,
+        content: prompt,
+        display: true,
+        details,
+    }, { triggerTurn: true, deliverAs: "followUp" });
+    if (!ctx.isIdle() && ctx.hasUI)
         ctx.ui.notify("VS Code diagnostic fix request queued.", "info");
 }
-function formatRange(range) {
+export function formatRange(range) {
     const start = formatPosition(range.start);
     const end = formatPosition(range.end);
     return start === end ? start : `${start}-${end}`;
 }
-function formatPosition(position) {
+export function formatPosition(position) {
     return `L${position.line + 1}:C${position.character + 1}`;
 }
-function formatDiagnosticCode(code) {
+export function formatDiagnosticCode(code) {
     if (typeof code === "string" || typeof code === "number")
         return String(code);
     return code.target ? `${code.value} (${code.target})` : String(code.value);

package/dist/src/pi/discovery.js

@@ -1,15 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sortCandidates = sortCandidates;
-exports.discoverIdeCandidates = discoverIdeCandidates;
-exports.resolveBestIdeCandidate = resolveBestIdeCandidate;
-const promises_1 = require("node:fs/promises");
-const node_path_1 = require("node:path");
-const protocol_1 = require("../shared/protocol");
-const paths_1 = require("../shared/paths");
-const schema_1 = require("../shared/schema");
-const platform_1 = require("../shared/platform");
-const ide_host_1 = require("./ide-host");
+import { readdir, readFile, rm, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { LOCK_FILE_EXTENSION } from "../shared/protocol.js";
+import { relationshipMatchLength, resolveLockDirs } from "../shared/paths.js";
+import { parseLockFileContent } from "../shared/schema.js";
+import { isWsl, normalizePathForHost } from "../shared/platform.js";
+import { IDE_HOST_TCP_PROBE_TIMEOUT_MS, resolveIdeHost, tcpReachable } from "./ide-host.js";
 function isProcessAlive(pid) {
     try {
         process.kill(pid, 0);
@@ -22,21 +17,21 @@ function isProcessAlive(pid) {
 function bestWorkspaceMatch(lock, cwd, env) {
     let best;
     for (const workspaceFolder of lock.workspaceFolders) {
-        const matchLength = (0, paths_1.relationshipMatchLength)(workspaceFolder, cwd, env);
+        const matchLength = relationshipMatchLength(workspaceFolder, cwd, env);
         if (matchLength <= 0)
             continue;
         if (!best || matchLength > best.matchLength) {
-            best = { matchLength, workspaceFolder: (0, platform_1.normalizePathForHost)(workspaceFolder, env) };
+            best = { matchLength, workspaceFolder: normalizePathForHost(workspaceFolder, env) };
         }
     }
     return best;
 }
-function sortCandidates(candidates) {
+export function sortCandidates(candidates) {
     return [...candidates].sort((a, b) => b.matchLength - a.matchLength || b.mtimeMs - a.mtimeMs || a.path.localeCompare(b.path));
 }
-async function discoverIdeCandidates(options) {
+export async function discoverIdeCandidates(options) {
     const env = options.env ?? process.env;
-    const lockDirs = (0, paths_1.resolveLockDirs)({
+    const lockDirs = resolveLockDirs({
         lockDir: options.lockDir,
         homeLockDir: options.homeLockDir,
         env,
@@ -54,20 +49,20 @@ async function discoverIdeCandidatesInDir(lockDir, options, env) {
     const checkPid = options.checkPid ?? true;
     let entries;
     try {
-        entries = await (0, promises_1.readdir)(lockDir);
+        entries = await readdir(lockDir);
     }
     catch {
         return [];
     }
     const candidates = [];
     for (const entry of entries) {
-        if (!entry.endsWith(protocol_1.LOCK_FILE_EXTENSION))
+        if (!entry.endsWith(LOCK_FILE_EXTENSION))
             continue;
-        const path = (0, node_path_1.join)(lockDir, entry);
+        const path = join(lockDir, entry);
         let content;
         let mtimeMs;
         try {
-            const [fileContent, fileStat] = await Promise.all([(0, promises_1.readFile)(path, "utf8"), (0, promises_1.stat)(path)]);
+            const [fileContent, fileStat] = await Promise.all([readFile(path, "utf8"), stat(path)]);
             content = fileContent;
             mtimeMs = fileStat.mtimeMs;
         }
@@ -75,31 +70,31 @@ async function discoverIdeCandidatesInDir(lockDir, options, env) {
             continue;
         }
         if (now - mtimeMs > maxAgeMs) {
-            await (0, promises_1.rm)(path, { force: true }).catch(() => undefined);
+            await rm(path, { force: true }).catch(() => undefined);
             continue;
         }
-        const lock = (0, schema_1.parseLockFileContent)(content);
+        const lock = parseLockFileContent(content);
         if (!lock) {
-            await (0, promises_1.rm)(path, { force: true }).catch(() => undefined);
+            await rm(path, { force: true }).catch(() => undefined);
             continue;
         }
         if (checkPid && typeof lock.pid === "number" && !isProcessAlive(lock.pid)) {
-            if (lock.runningInWindows === true && (0, platform_1.isWsl)(env)) {
+            if (lock.runningInWindows === true && isWsl(env)) {
                 const reachable = await isDeadWindowsPidLockReachable(lock, options, env);
                 if (!reachable) {
-                    await (0, promises_1.rm)(path, { force: true }).catch(() => undefined);
+                    await rm(path, { force: true }).catch(() => undefined);
                     continue;
                 }
             }
             else {
-                await (0, promises_1.rm)(path, { force: true }).catch(() => undefined);
+                await rm(path, { force: true }).catch(() => undefined);
                 continue;
             }
         }
         const match = bestWorkspaceMatch(lock, options.cwd, env);
         const { matchLength, workspaceFolder } = match ?? {
             matchLength: 0,
-            workspaceFolder: lock.workspaceFolders[0] ? (0, platform_1.normalizePathForHost)(lock.workspaceFolders[0], env) : "",
+            workspaceFolder: lock.workspaceFolders[0] ? normalizePathForHost(lock.workspaceFolders[0], env) : "",
         };
         candidates.push({ path, lock, mtimeMs, matchLength, workspaceFolder });
     }
@@ -107,13 +102,13 @@ async function discoverIdeCandidatesInDir(lockDir, options, env) {
 }
 async function isDeadWindowsPidLockReachable(lock, options, env) {
     try {
-        const host = await (options.resolveHost ?? ((ideLock) => (0, ide_host_1.resolveIdeHost)(ideLock, { env, tcpProbe: options.tcpProbe })))(lock);
-        return await (options.tcpProbe ?? ide_host_1.tcpReachable)(host, lock.port, ide_host_1.IDE_HOST_TCP_PROBE_TIMEOUT_MS);
+        const host = await (options.resolveHost ?? ((ideLock) => resolveIdeHost(ideLock, { env, tcpProbe: options.tcpProbe })))(lock);
+        return await (options.tcpProbe ?? tcpReachable)(host, lock.port, IDE_HOST_TCP_PROBE_TIMEOUT_MS);
     }
     catch {
         return false;
     }
 }
-async function resolveBestIdeCandidate(options) {
+export async function resolveBestIdeCandidate(options) {
     return (await discoverIdeCandidates(options))[0];
 }