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

package/dist/src/pi/chunks/chunk-UUXVCTOS.js

@@ -0,0 +1,819 @@
+import { createRequire as __piCreateRequire } from "node:module";const require = __piCreateRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/shared/errors.ts
+var extensionErrorReporter;
+function setExtensionErrorReporter(reporter) {
+  extensionErrorReporter = reporter;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isStaleContextError(error) {
+  return errorMessage(error).includes("stale after session replacement or reload");
+}
+function toError(error, prefix) {
+  if (error instanceof Error) {
+    if (!prefix) return error;
+    return new Error(`${prefix}: ${error.message}`, { cause: error });
+  }
+  return new Error(prefix ? `${prefix}: ${String(error)}` : String(error));
+}
+function formatExtensionError(scope, error) {
+  return `[pi-x-ide] ${scope}: ${errorMessage(error)}`;
+}
+function logExtensionError(scope, error) {
+  extensionErrorReporter?.(scope, error);
+}
+function safeRun(scope, action, onError) {
+  try {
+    return action();
+  } catch (error) {
+    if (onError) onError(error);
+    else logExtensionError(scope, error);
+    return void 0;
+  }
+}
+async function safeRunAsync(scope, action, onError) {
+  try {
+    return await action();
+  } catch (error) {
+    if (onError) onError(error);
+    else logExtensionError(scope, error);
+    return void 0;
+  }
+}
+
+// src/shared/config-options.ts
+var CONFIG_ENV_VALUE_TYPES = ["string", "number", "boolean"];
+function isConfigEnvValue(value) {
+  return CONFIG_ENV_VALUE_TYPES.some((type) => typeof value === type);
+}
+var STATUS_DISPLAY_VALUES = ["widget", "statusline"];
+var DEFAULT_STATUS_DISPLAY = "widget";
+
+// src/shared/config.ts
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, resolve } from "node:path";
+var EXT_CONFIG_NAME = "pi-x-ide";
+var CONFIG_DIR_NAME = ".pi";
+var PI_CONFIG_FILE = "config.json";
+var STATUS_DISPLAY_CONFIG_KEY = "status_display";
+var AUTO_INSTALL_ENV_KEY = "PI_X_IDE_AUTO_INSTALL";
+var processEnvOverlays = /* @__PURE__ */ new WeakSet();
+var AUTO_INSTALL_DISABLED_VALUES = /* @__PURE__ */ new Set(["0", "false", "off"]);
+function resolvePiConfigPath(home = homedir()) {
+  return resolvePiGlobalConfigPath(home);
+}
+function resolvePiGlobalConfigPath(home = homedir()) {
+  return resolve(home, CONFIG_DIR_NAME, EXT_CONFIG_NAME, PI_CONFIG_FILE);
+}
+function resolvePiProjectConfigPath(projectDir) {
+  return resolve(projectDir, CONFIG_DIR_NAME, EXT_CONFIG_NAME, PI_CONFIG_FILE);
+}
+function readPiConfigFile(configPath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(configPath, "utf8"));
+  } catch {
+    return void 0;
+  }
+  return isRecord(parsed) ? parsed : void 0;
+}
+function writePiConfigFile(partial, configPath) {
+  const existing = readPiConfigFile(configPath) ?? {};
+  const merged = { ...existing, ...partial };
+  if (isRecord(existing.env) || isRecord(partial.env)) {
+    merged.env = {
+      ...isRecord(existing.env) ? existing.env : {},
+      ...isRecord(partial.env) ? partial.env : {}
+    };
+  }
+  mkdirSync(dirname(configPath), { recursive: true });
+  writeFileSync(configPath, `${JSON.stringify(merged, null, 2)}
+`, "utf8");
+}
+function readPiConfigEnv(configPath = resolvePiConfigPath()) {
+  const parsed = readPiConfigFile(configPath);
+  if (!parsed || !isRecord(parsed.env)) return {};
+  return Object.fromEntries(
+    Object.entries(parsed.env).filter((entry) => {
+      const [key, value] = entry;
+      return key.length > 0 && isConfigEnvValue(value);
+    }).map(([key, value]) => [key, String(value)])
+  );
+}
+function resolvePiConfigEnv(env = process.env, options = {}) {
+  if (env !== process.env && !options.configPath && options.projectDir === void 0) {
+    return env;
+  }
+  const configEnv = options.configPath ? readPiConfigEnv(options.configPath) : {
+    ...readPiConfigEnv(resolvePiGlobalConfigPath(options.home)),
+    ...options.projectDir ? readPiConfigEnv(resolvePiProjectConfigPath(options.projectDir)) : {}
+  };
+  if (Object.keys(configEnv).length === 0) return env;
+  const merged = { ...configEnv, ...env };
+  if (env === process.env) processEnvOverlays.add(merged);
+  return merged;
+}
+function isProcessEnvOrPiConfigOverlay(env) {
+  return env === process.env || processEnvOverlays.has(env);
+}
+function readPiConfigFixPrompt(configPath = resolvePiConfigPath()) {
+  const parsed = readPiConfigFile(configPath);
+  if (!parsed) return void 0;
+  return typeof parsed.fixPrompt === "string" ? parsed.fixPrompt : void 0;
+}
+function readPiConfigStatusDisplay(configPathOrOptions = {}) {
+  return resolvePiConfigStatusDisplay(configPathOrOptions).value;
+}
+function resolvePiConfigStatusDisplay(configPathOrOptions = {}) {
+  if (typeof configPathOrOptions === "string") {
+    const value = readStatusDisplayFromFile(configPathOrOptions);
+    return value === void 0 ? { value: DEFAULT_STATUS_DISPLAY, scope: "default" } : { value, scope: "global", path: configPathOrOptions };
+  }
+  const projectDir = configPathOrOptions.projectDir;
+  if (projectDir) {
+    const projectPath = resolvePiProjectConfigPath(projectDir);
+    const projectValue = readStatusDisplayFromFile(projectPath);
+    if (projectValue !== void 0) {
+      return { value: projectValue, scope: "project", path: projectPath };
+    }
+  }
+  const globalPath = resolvePiGlobalConfigPath(configPathOrOptions.home);
+  const globalValue = readStatusDisplayFromFile(globalPath);
+  if (globalValue !== void 0) {
+    return { value: globalValue, scope: "global", path: globalPath };
+  }
+  return { value: DEFAULT_STATUS_DISPLAY, scope: "default" };
+}
+function resolvePiConfigAutoInstall(configPathOrOptions = {}) {
+  if (typeof configPathOrOptions === "string") {
+    const raw = readEnvValueFromFile(configPathOrOptions, AUTO_INSTALL_ENV_KEY);
+    return raw === void 0 ? { value: true, scope: "default" } : { value: parseAutoInstallValue(raw), scope: "global", path: configPathOrOptions };
+  }
+  const projectDir = configPathOrOptions.projectDir;
+  if (projectDir) {
+    const projectPath = resolvePiProjectConfigPath(projectDir);
+    const projectRaw = readEnvValueFromFile(projectPath, AUTO_INSTALL_ENV_KEY);
+    if (projectRaw !== void 0) {
+      return { value: parseAutoInstallValue(projectRaw), scope: "project", path: projectPath };
+    }
+  }
+  const globalPath = resolvePiGlobalConfigPath(configPathOrOptions.home);
+  const globalRaw = readEnvValueFromFile(globalPath, AUTO_INSTALL_ENV_KEY);
+  if (globalRaw !== void 0) {
+    return { value: parseAutoInstallValue(globalRaw), scope: "global", path: globalPath };
+  }
+  return { value: true, scope: "default" };
+}
+function resolveIdeConfigSettings(options = {}) {
+  const display = resolvePiConfigStatusDisplay(options);
+  const autoInstall = resolvePiConfigAutoInstall(options);
+  return {
+    settings: {
+      display: display.value,
+      autoInstall: autoInstall.value
+    },
+    display,
+    autoInstall
+  };
+}
+function writePiConfigSettings(settings, options) {
+  const path = options.scope === "project" ? resolvePiProjectConfigPath(requireProjectDir(options.projectDir)) : resolvePiGlobalConfigPath(options.home);
+  const partial = {};
+  if (settings.display !== void 0) {
+    partial[STATUS_DISPLAY_CONFIG_KEY] = settings.display;
+  }
+  if (settings.autoInstall !== void 0) {
+    partial.env = {
+      [AUTO_INSTALL_ENV_KEY]: settings.autoInstall ? "true" : "false"
+    };
+  }
+  writePiConfigFile(partial, path);
+  return { path, scope: options.scope };
+}
+function parseAutoInstallValue(value) {
+  return !AUTO_INSTALL_DISABLED_VALUES.has(value.trim().toLowerCase());
+}
+function requireProjectDir(projectDir) {
+  if (!projectDir) {
+    throw new Error("projectDir is required when saving project config");
+  }
+  return projectDir;
+}
+function readStatusDisplayFromFile(configPath) {
+  const parsed = readPiConfigFile(configPath);
+  if (!parsed || typeof parsed[STATUS_DISPLAY_CONFIG_KEY] !== "string") return void 0;
+  const value = parsed[STATUS_DISPLAY_CONFIG_KEY];
+  return isStatusDisplay(value) ? value : void 0;
+}
+function readEnvValueFromFile(configPath, key) {
+  const env = readPiConfigEnv(configPath);
+  return env[key];
+}
+function isStatusDisplay(value) {
+  return STATUS_DISPLAY_VALUES.includes(value);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/shared/paths.ts
+import { realpathSync } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { isAbsolute, relative, resolve as resolve3, sep } from "node:path";
+
+// src/shared/platform.ts
+import { readdirSync, readFileSync as readFileSync2 } from "node:fs";
+import { resolve as resolve2 } from "node:path";
+var WINDOWS_SYSTEM_PROFILES = /* @__PURE__ */ new Set(["public", "default", "default user", "all users"]);
+function isWsl(env = process.env) {
+  const configuredEnv = resolvePiConfigEnv(env);
+  if (configuredEnv.WSL_DISTRO_NAME || configuredEnv.WSL_INTEROP) return true;
+  if (!isProcessEnvOrPiConfigOverlay(configuredEnv)) return false;
+  try {
+    return /microsoft|wsl/i.test(readFileSync2("/proc/version", "utf8"));
+  } catch {
+    return false;
+  }
+}
+function normalizePathForHost(input, env = process.env) {
+  const configuredEnv = resolvePiConfigEnv(env);
+  if (!input || !isWsl(configuredEnv)) return input;
+  const driveMatch = input.match(/^([a-zA-Z]):[\\/](.*)$/);
+  if (driveMatch) {
+    const drive = driveMatch[1].toLowerCase();
+    const rest = driveMatch[2].replaceAll("\\", "/");
+    return `/mnt/${drive}/${rest}`;
+  }
+  const uncMatch = input.match(/^[\\/]{2}(?:wsl\$|wsl\.localhost)[\\/]([^\\/]+)[\\/](.*)$/i);
+  if (uncMatch) {
+    const distro = uncMatch[1];
+    const rest = uncMatch[2].replaceAll("\\", "/");
+    const currentDistro = configuredEnv.WSL_DISTRO_NAME;
+    if (!currentDistro || distro.toLowerCase() === currentDistro.toLowerCase()) {
+      return `/${rest}`;
+    }
+  }
+  return input;
+}
+function windowsUserProfileDirs(usersRoot = "/mnt/c/Users", env = process.env) {
+  if (!isWsl(env)) return [];
+  try {
+    return readdirSync(usersRoot, { withFileTypes: true }).filter(
+      (entry) => entry.isDirectory() && !entry.name.startsWith(".") && !WINDOWS_SYSTEM_PROFILES.has(entry.name.toLowerCase())
+    ).map((entry) => resolve2(usersRoot, entry.name));
+  } catch {
+    return [];
+  }
+}
+function normalizeEditorSelectionSnapshotForHost(snapshot, env = process.env) {
+  return {
+    ...snapshot,
+    filePath: normalizePathForHost(snapshot.filePath, env),
+    workspaceFolder: snapshot.workspaceFolder ? normalizePathForHost(snapshot.workspaceFolder, env) : void 0
+  };
+}
+
+// src/shared/paths.ts
+function resolveLockDir() {
+  return resolve3(homedir2(), CONFIG_DIR_NAME, EXT_CONFIG_NAME, "lock");
+}
+function resolveLockDirs(options = {}) {
+  if (options.lockDir) return [resolve3(options.lockDir)];
+  const dirs = [resolve3(options.homeLockDir ?? resolveLockDir())];
+  for (const profileDir of windowsUserProfileDirs(options.windowsUsersRoot, options.env)) {
+    dirs.push(resolve3(profileDir, CONFIG_DIR_NAME, EXT_CONFIG_NAME, "lock"));
+  }
+  return dedupePaths(dirs);
+}
+function dedupePaths(paths) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const path of paths) {
+    const resolved = resolve3(path);
+    let key = resolved;
+    try {
+      key = realpathSync(resolved);
+    } catch {
+    }
+    if (seen.has(key)) continue;
+    seen.add(key);
+    deduped.push(resolved);
+  }
+  return deduped;
+}
+function normalizePath(input) {
+  const resolved = resolve3(input);
+  if (process.platform === "win32" && resolved.length >= 2 && resolved[1] === ":") {
+    return resolved[0].toUpperCase() + resolved.slice(1);
+  }
+  return resolved;
+}
+function normalizePathForComparison(input, env = process.env) {
+  return normalizePath(normalizePathForHost(input, env));
+}
+function isPathInsideOrEqual(parent, child) {
+  const normalizedParent = normalizePath(parent);
+  const normalizedChild = normalizePath(child);
+  if (normalizedParent === normalizedChild) return true;
+  const rel = relative(normalizedParent, normalizedChild);
+  return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
+}
+function hasDirectWorkspaceMatch(workspaceFolders, cwd, env = process.env) {
+  const normalizedCwd = normalizePathForComparison(cwd, env);
+  return workspaceFolders.some(
+    (workspaceFolder) => isPathInsideOrEqual(normalizePathForComparison(workspaceFolder, env), normalizedCwd)
+  );
+}
+function relationshipMatchLength(workspaceFolder, cwd, env = process.env) {
+  const workspace = normalizePathForComparison(workspaceFolder, env);
+  const active = normalizePathForComparison(cwd, env);
+  if (isPathInsideOrEqual(workspace, active)) {
+    return workspace.length + 1e4;
+  }
+  if (isPathInsideOrEqual(active, workspace)) {
+    return active.length;
+  }
+  return 0;
+}
+function toRelativeDisplayPath(filePath, workspaceFolder, cwd, env = process.env) {
+  const base = workspaceFolder ?? cwd;
+  if (!base) return normalizePathForHost(filePath, env);
+  const normalizedFilePath = normalizePathForHost(filePath, env);
+  const normalizedBase = normalizePathForHost(base, env);
+  const rel = relative(normalizedBase, normalizedFilePath);
+  if (!rel || rel.startsWith("..") || isAbsolute(rel)) return normalizedFilePath;
+  return rel.split(sep).join("/");
+}
+
+// src/shared/format.ts
+function rangeToLineSpan(range) {
+  return {
+    startLine: range.selection.start.line + 1,
+    endLine: range.selection.end.line + 1
+  };
+}
+function formatLineRange(range) {
+  const { startLine, endLine } = rangeToLineSpan(range);
+  return startLine === endLine ? `L${startLine}` : `L${startLine}-L${endLine}`;
+}
+function formatLineSpan(range) {
+  return `#${formatLineRange(range)}`;
+}
+function formatRangeMention(snapshot, options = {}) {
+  const rel = toRelativeDisplayPath(snapshot.filePath, snapshot.workspaceFolder, options.cwd, options.env);
+  const first = snapshot.ranges[0];
+  return first ? `@${rel}${formatLineSpan(first)}` : `@${rel}`;
+}
+function describeRanges(ranges) {
+  if (ranges.length === 0) return "open file";
+  if (ranges.length === 1) return formatLineSpan(ranges[0]);
+  return ranges.map((range, index) => `${index + 1}:${formatLineSpan(range)}`).join(" ");
+}
+function snapshotKey(snapshot) {
+  return JSON.stringify({
+    source: snapshot.source,
+    filePath: snapshot.filePath,
+    workspaceFolder: snapshot.workspaceFolder,
+    ranges: snapshot.ranges.map((range) => ({
+      start: range.selection.start,
+      end: range.selection.end,
+      textLength: range.text.length
+    }))
+  });
+}
+function formatEditorContextMessage(snapshot, options = {}) {
+  const filePath = toRelativeDisplayPath(
+    snapshot.filePath,
+    snapshot.workspaceFolder,
+    void 0,
+    options.env
+  ).replaceAll("`", "\\`");
+  const lines = ["### IDE Context", `- **IDE**: ${snapshot.source}`, `- **File**: \`${filePath}\``];
+  if (snapshot.ranges.length > 0) {
+    lines.push(`- **Selection**: ${snapshot.ranges.map(formatLineRange).join(", ")}`);
+  }
+  return lines.join("\n");
+}
+
+// src/pi/ui.ts
+import { basename } from "node:path";
+
+// src/shared/display-width.ts
+var ESC = String.fromCharCode(27);
+var ANSI_PATTERN = new RegExp(`${ESC}\\[[0-?]*[ -/]*[@-~]`, "g");
+var EMOJI_VARIATION_SELECTOR = 65039;
+var COMBINING_ENCLOSING_KEYCAP = 8419;
+var graphemeSegmenter = typeof Intl.Segmenter === "function" ? new Intl.Segmenter(void 0, { granularity: "grapheme" }) : void 0;
+function visibleWidth(input) {
+  let width = 0;
+  for (const grapheme of graphemes(stripAnsi(input))) width += graphemeWidth(grapheme);
+  return width;
+}
+function truncateToWidth(input, maxWidth, ellipsis = "...", pad = false) {
+  if (maxWidth <= 0) return "";
+  const inputWidth = visibleWidth(input);
+  if (inputWidth <= maxWidth) return padToWidth(input, maxWidth, pad);
+  const suffix = fitSuffix(ellipsis, maxWidth);
+  const suffixWidth = visibleWidth(suffix);
+  const contentLimit = Math.max(0, maxWidth - suffixWidth);
+  let output = "";
+  let used = 0;
+  for (const grapheme of graphemes(stripAnsi(input))) {
+    const width = graphemeWidth(grapheme);
+    if (used + width > contentLimit) break;
+    output += grapheme;
+    used += width;
+  }
+  return padToWidth(output + suffix, maxWidth, pad);
+}
+function stripAnsi(input) {
+  return input.replace(ANSI_PATTERN, "");
+}
+function* graphemes(input) {
+  if (graphemeSegmenter) {
+    for (const segment of graphemeSegmenter.segment(input)) yield segment.segment;
+    return;
+  }
+  yield* input;
+}
+function padToWidth(input, maxWidth, pad) {
+  if (!pad) return input;
+  return input + " ".repeat(Math.max(0, maxWidth - visibleWidth(input)));
+}
+function fitSuffix(ellipsis, maxWidth) {
+  if (visibleWidth(ellipsis) <= maxWidth) return ellipsis;
+  let output = "";
+  let used = 0;
+  for (const grapheme of graphemes(stripAnsi(ellipsis))) {
+    const width = graphemeWidth(grapheme);
+    if (used + width > maxWidth) break;
+    output += grapheme;
+    used += width;
+  }
+  return output;
+}
+function graphemeWidth(grapheme) {
+  if (grapheme.length === 0) return 0;
+  const codePoints = [...grapheme].map((char) => char.codePointAt(0)).filter((value) => value !== void 0);
+  if (codePoints.every(isZeroWidthCodePoint)) return 0;
+  if (codePoints.every(isControlCodePoint)) return 0;
+  if (codePoints.includes(EMOJI_VARIATION_SELECTOR) || codePoints.includes(COMBINING_ENCLOSING_KEYCAP)) return 2;
+  return codePoints.some(isWideCodePoint) ? 2 : 1;
+}
+function isZeroWidthCodePoint(codePoint) {
+  return codePoint >= 768 && codePoint <= 879 || codePoint >= 6832 && codePoint <= 6911 || codePoint >= 7616 && codePoint <= 7679 || codePoint >= 8400 && codePoint <= 8447 || codePoint >= 65056 && codePoint <= 65071 || codePoint === 8205 || codePoint === 65038 || codePoint === 65039;
+}
+function isControlCodePoint(codePoint) {
+  return codePoint <= 31 || codePoint >= 127 && codePoint <= 159;
+}
+function isWideCodePoint(codePoint) {
+  return codePoint >= 4352 && codePoint <= 4607 || codePoint >= 11904 && codePoint <= 42191 || codePoint >= 44032 && codePoint <= 55203 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65040 && codePoint <= 65049 || codePoint >= 65072 && codePoint <= 65135 || codePoint >= 65280 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510 || codePoint >= 127462 && codePoint <= 127487 || codePoint >= 127744 && codePoint <= 129791 || codePoint >= 131072 && codePoint <= 262141;
+}
+
+// src/pi/ui.ts
+var IDE_ICON = "\u29C9";
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var SPINNER_INTERVAL_MS = 90;
+var PI_THEME_KEYS = [
+  /* @__PURE__ */ Symbol.for("@earendil-works/pi-coding-agent:theme"),
+  /* @__PURE__ */ Symbol.for("@mariozechner/pi-coding-agent:theme")
+];
+var statuslineSpinner = { frame: 0 };
+function getActiveUiContext(ctx) {
+  if (!ctx) return void 0;
+  try {
+    if (!ctx.hasUI) return void 0;
+    return { cwd: ctx.cwd, ui: ctx.ui };
+  } catch (error) {
+    if (!isStaleContextError(error)) logExtensionError("read active Pi UI context", error);
+    return void 0;
+  }
+}
+function runReportingUiFailure(scope, action) {
+  try {
+    action();
+  } catch (error) {
+    logExtensionError(scope, error);
+  }
+}
+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);
+}
+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 = void 0;
+                }
+              }
+            }, SPINNER_INTERVAL_MS);
+            timer.unref?.();
+          } else if (!active && timer) {
+            clearInterval(timer);
+            timer = void 0;
+          }
+        };
+        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 = void 0;
+}
+function clearWidget(uiContext) {
+  runReportingUiFailure("clear IDE UI widget", () => uiContext.ui.setWidget(EXT_CONFIG_NAME, void 0));
+}
+function clearStatusline(uiContext) {
+  runReportingUiFailure("clear IDE statusline", () => uiContext.ui.setStatus(EXT_CONFIG_NAME, void 0));
+}
+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;
+}
+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: "\u2715", color: "error" }
+      ];
+    case "connected":
+      return buildConnectedSegments(runtime);
+    default:
+      return [];
+  }
+}
+function buildStatusText(runtime, spinnerFrame = SPINNER_FRAMES[0], colorize) {
+  const segments = buildStatusSegments(runtime, spinnerFrame);
+  if (segments.length === 0) return void 0;
+  return formatStatusSegments(segments, colorize);
+}
+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 void 0;
+  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 void 0;
+}
+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} \u2713`, color: "dim" }];
+  const rel = basename(selection.filePath);
+  const range = describeRanges(selection.ranges);
+  const pending = runtime.attachState === "pending";
+  const marker = pending ? "\u21E1" : "\u2713";
+  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 }
+  ];
+}
+function buildWidget(runtime, cwd) {
+  if (!runtime.enabled || runtime.connectionStatus === "disabled") return void 0;
+  if (runtime.connectionStatus !== "connected" && runtime.connectionStatus !== "connecting" && runtime.connectionStatus !== "error") {
+    return void 0;
+  }
+  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;
+}
+
+export {
+  __require,
+  __commonJS,
+  __toESM,
+  setExtensionErrorReporter,
+  errorMessage,
+  isStaleContextError,
+  toError,
+  formatExtensionError,
+  logExtensionError,
+  safeRun,
+  safeRunAsync,
+  STATUS_DISPLAY_VALUES,
+  DEFAULT_STATUS_DISPLAY,
+  EXT_CONFIG_NAME,
+  resolvePiConfigEnv,
+  readPiConfigFixPrompt,
+  resolveIdeConfigSettings,
+  writePiConfigSettings,
+  isWsl,
+  normalizePathForHost,
+  normalizeEditorSelectionSnapshotForHost,
+  resolveLockDirs,
+  isPathInsideOrEqual,
+  hasDirectWorkspaceMatch,
+  relationshipMatchLength,
+  toRelativeDisplayPath,
+  formatRangeMention,
+  snapshotKey,
+  formatEditorContextMessage,
+  visibleWidth,
+  updateIdeUi,
+  clearIdeUi,
+  buildWidget
+};