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

package/dist/src/pi/zed.js

@@ -0,0 +1,409 @@
+import { copyFileSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import * as Effect from "effect/Effect";
+import * as Fiber from "effect/Fiber";
+import { resolvePiConfigEnv } from "../shared/config.js";
+import { isWsl, normalizePathForHost } from "../shared/platform.js";
+import { snapshotKey } from "../shared/format.js";
+import { isPathInsideOrEqual } from "../shared/paths.js";
+import { clearLatestSelection, setLatestSelection } from "./selection.js";
+import { containPiError } from "./safety.js";
+import { updateIdeUi } from "./ui.js";
+export { isWsl };
+export const PI_X_IDE_ZED_DB_ENV = "PI_X_IDE_ZED_DB";
+export const PI_X_IDE_ZED_POLL_INTERVAL_MS_ENV = "PI_X_IDE_ZED_POLL_INTERVAL_MS";
+export const ZED_POLL_INTERVAL_MS = 1000;
+export const ZED_POLL_INTERVAL_MS_MIN = 100;
+export const ZED_POLL_INTERVAL_MS_MAX = 2000;
+export function isZedTerminal(env = process.env) {
+    const configuredEnv = resolvePiConfigEnv(env);
+    return configuredEnv.ZED_TERM === "true" || configuredEnv.TERM_PROGRAM?.toLowerCase() === "zed";
+}
+export function normalizeZedPathForHost(input, env = process.env) {
+    return normalizePathForHost(input, env);
+}
+export function resolveZedDbPath(env = process.env, home = homedir()) {
+    const configuredEnv = resolvePiConfigEnv(env);
+    const override = configuredEnv[PI_X_IDE_ZED_DB_ENV]?.trim();
+    if (override) {
+        const normalizedOverride = normalizeZedPathForHost(override, configuredEnv);
+        return isFile(normalizedOverride) ? normalizedOverride : undefined;
+    }
+    const candidates = [
+        resolve(home, ".local", "share", "zed", "db", "0-stable", "db.sqlite"),
+        resolve(home, "Library", "Application Support", "Zed", "db", "0-stable", "db.sqlite"),
+        resolve(home, "AppData", "Local", "Zed", "db", "0-stable", "db.sqlite"),
+        ...zedDbCandidatesFromWindowsEnv(configuredEnv),
+        ...zedDbCandidatesFromWslMount(configuredEnv),
+    ];
+    return candidates.find(isFile);
+}
+function zedDbCandidatesFromWindowsEnv(env) {
+    const localAppData = env.LOCALAPPDATA?.trim();
+    if (localAppData)
+        return [resolve(normalizeZedPathForHost(localAppData, env), "Zed", "db", "0-stable", "db.sqlite")];
+    const userProfile = env.USERPROFILE?.trim();
+    if (userProfile) {
+        return [
+            resolve(normalizeZedPathForHost(userProfile, env), "AppData", "Local", "Zed", "db", "0-stable", "db.sqlite"),
+        ];
+    }
+    return [];
+}
+function zedDbCandidatesFromWslMount(env) {
+    if (!isWsl(env))
+        return [];
+    const usersRoot = "/mnt/c/Users";
+    try {
+        return readdirSync(usersRoot, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory() && !entry.name.startsWith("."))
+            .map((entry) => resolve(usersRoot, entry.name, "AppData", "Local", "Zed", "db", "0-stable", "db.sqlite"));
+    }
+    catch {
+        return [];
+    }
+}
+function isFile(path) {
+    try {
+        return statSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function openZedDatabase(dbPath, env = process.env) {
+    const configuredEnv = resolvePiConfigEnv(env);
+    if (isWsl(configuredEnv))
+        return openZedDatabaseSnapshot(dbPath);
+    try {
+        return { db: new DatabaseSync(dbPath, { readOnly: true }), cleanup: () => undefined };
+    }
+    catch {
+        return openZedDatabaseSnapshot(dbPath);
+    }
+}
+function openZedDatabaseSnapshot(dbPath) {
+    let snapshotDir;
+    try {
+        snapshotDir = mkdtempSync(join(tmpdir(), "pi-x-ide-zed-db-"));
+        const cleanupDir = snapshotDir;
+        const snapshotPath = join(cleanupDir, "db.sqlite");
+        copyFileSync(dbPath, snapshotPath);
+        for (const suffix of ["-wal", "-shm"]) {
+            const sidecarPath = `${dbPath}${suffix}`;
+            if (isFile(sidecarPath))
+                copyFileSync(sidecarPath, `${snapshotPath}${suffix}`);
+        }
+        try {
+            const dbRW = new DatabaseSync(snapshotPath);
+            dbRW.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+            dbRW.close();
+        }
+        catch {
+        }
+        return {
+            db: new DatabaseSync(snapshotPath, { readOnly: true }),
+            cleanup: () => rmSync(cleanupDir, { recursive: true, force: true }),
+        };
+    }
+    catch {
+        if (snapshotDir)
+            rmSync(snapshotDir, { recursive: true, force: true });
+        return undefined;
+    }
+}
+export function parseZedWorkspacePaths(value) {
+    if (!value)
+        return [];
+    const trimmed = value.trim();
+    if (!trimmed)
+        return [];
+    if (trimmed.startsWith("[") || trimmed.startsWith("{")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            return Array.isArray(parsed)
+                ? parsed.filter((item) => typeof item === "string" && item.length > 0)
+                : [];
+        }
+        catch {
+            return [];
+        }
+    }
+    return trimmed
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+}
+function utf8ByteOffsetToStringIndex(text, byteOffset) {
+    if (byteOffset <= 0)
+        return 0;
+    const encoder = new TextEncoder();
+    let bytes = 0;
+    for (let index = 0; index < text.length;) {
+        const codePoint = text.codePointAt(index);
+        if (codePoint === undefined)
+            return text.length;
+        const nextIndex = index + (codePoint > 0xffff ? 2 : 1);
+        bytes += encoder.encode(text.slice(index, nextIndex)).length;
+        if (bytes >= byteOffset)
+            return nextIndex;
+        index = nextIndex;
+    }
+    return text.length;
+}
+function byteOffsetToSelection(text, startByte, endByte) {
+    const startIndex = utf8ByteOffsetToStringIndex(text, startByte);
+    const endIndex = utf8ByteOffsetToStringIndex(text, endByte);
+    const lines = text.split("\n");
+    let startLine = 0;
+    let startChar = 0;
+    let remaining = startIndex;
+    for (let lineIdx = 0; lineIdx < lines.length && remaining >= 0; lineIdx += 1) {
+        const lineLen = lines[lineIdx].length + 1;
+        if (remaining <= lines[lineIdx].length) {
+            startLine = lineIdx;
+            startChar = remaining;
+            break;
+        }
+        remaining -= lineLen;
+    }
+    let endLine = 0;
+    let endChar = 0;
+    remaining = endIndex;
+    for (let lineIdx = 0; lineIdx < lines.length && remaining >= 0; lineIdx += 1) {
+        const lineLen = lines[lineIdx].length + 1;
+        if (remaining <= lines[lineIdx].length) {
+            endLine = lineIdx;
+            endChar = remaining;
+            break;
+        }
+        remaining -= lineLen;
+    }
+    return {
+        start: { line: startLine, character: startChar },
+        end: { line: endLine, character: endChar },
+    };
+}
+function scoreWorkspace(workspacePaths, cwd, env) {
+    const normalizedCwd = normalizeZedPathForHost(cwd, env);
+    return parseZedWorkspacePaths(workspacePaths).reduce((best, workspacePath) => {
+        const normalizedWorkspacePath = normalizeZedPathForHost(workspacePath, env);
+        if (isPathInsideOrEqual(normalizedWorkspacePath, normalizedCwd)) {
+            const resolved = resolve(normalizedWorkspacePath);
+            return Math.max(best, resolved.length);
+        }
+        return best;
+    }, 0);
+}
+export function resolveZedSelection(options) {
+    const { dbPath, cwd, readFile = (path) => readFileSync(path, "utf8"), env: inputEnv = process.env } = options;
+    const env = resolvePiConfigEnv(inputEnv);
+    const dbHandle = openZedDatabase(dbPath, env);
+    if (!dbHandle)
+        return undefined;
+    const { db, cleanup } = dbHandle;
+    try {
+        const rows = db
+            .prepare(`SELECT i.kind AS item_kind,
+                e.item_id AS editor_id,
+                i.workspace_id,
+                w.paths AS workspace_paths,
+                w.timestamp,
+                e.buffer_path
+         FROM items i
+         JOIN panes p ON p.pane_id = i.pane_id AND p.workspace_id = i.workspace_id
+         JOIN workspaces w ON w.workspace_id = i.workspace_id
+         LEFT JOIN editors e ON e.item_id = i.item_id AND e.workspace_id = i.workspace_id
+         WHERE i.active = 1 AND p.active = 1
+         ORDER BY w.timestamp DESC`)
+            .all();
+        const scored = rows
+            .filter((row) => row.item_kind === "Editor" && row.editor_id != null && typeof row.buffer_path === "string")
+            .map((row) => ({
+            ...row,
+            score: scoreWorkspace(row.workspace_paths, cwd, env),
+        }))
+            .filter((row) => row.score > 0);
+        if (scored.length === 0)
+            return undefined;
+        scored.sort((a, b) => b.score - a.score || b.timestamp - a.timestamp);
+        const best = scored[0];
+        if (!best)
+            return undefined;
+        const { editor_id, workspace_id, buffer_path, workspace_paths } = best;
+        const normalizedBufferPath = normalizeZedPathForHost(buffer_path, env);
+        const workspaceFolder = bestWorkspaceFolder(workspace_paths, cwd, env);
+        let contents;
+        const contentRow = db
+            .prepare("SELECT contents FROM editors WHERE item_id = ? AND workspace_id = ?")
+            .get(editor_id, workspace_id);
+        if (contentRow && typeof contentRow.contents === "string") {
+            contents = contentRow.contents;
+        }
+        else {
+            try {
+                contents = readFile(normalizedBufferPath);
+            }
+            catch {
+                return undefined;
+            }
+        }
+        if (contents === undefined)
+            return undefined;
+        const selectionRows = db
+            .prepare("SELECT start AS selection_start, end AS selection_end FROM editor_selections WHERE editor_id = ? AND workspace_id = ?")
+            .all(editor_id, workspace_id);
+        const ranges = [];
+        for (const sel of selectionRows) {
+            const rawStart = sel.selection_start;
+            const rawEnd = sel.selection_end;
+            const start = Math.min(rawStart, rawEnd);
+            const end = Math.max(rawStart, rawEnd);
+            if (start >= end)
+                continue;
+            const text = contents.slice(utf8ByteOffsetToStringIndex(contents, start), utf8ByteOffsetToStringIndex(contents, end));
+            if (!text)
+                continue;
+            const selection = byteOffsetToSelection(contents, start, end);
+            ranges.push({ text, selection });
+        }
+        return {
+            source: "zed",
+            filePath: normalizedBufferPath,
+            workspaceFolder,
+            ranges,
+            receivedAt: options.now ?? Date.now(),
+        };
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        try {
+            db.close();
+        }
+        finally {
+            cleanup();
+        }
+    }
+}
+function bestWorkspaceFolder(workspacePaths, cwd, env) {
+    const paths = parseZedWorkspacePaths(workspacePaths).map((workspacePath) => normalizeZedPathForHost(workspacePath, env));
+    const normalizedCwd = normalizeZedPathForHost(cwd, env);
+    const matches = paths.filter((workspacePath) => isPathInsideOrEqual(workspacePath, normalizedCwd));
+    if (matches.length === 0)
+        return paths[0];
+    return matches.sort((a, b) => resolve(b).length - resolve(a).length)[0];
+}
+export function resolveZedPollIntervalMs(env = process.env, intervalMs) {
+    const configuredEnv = resolvePiConfigEnv(env);
+    const configuredIntervalRaw = configuredEnv[PI_X_IDE_ZED_POLL_INTERVAL_MS_ENV];
+    let configuredInterval;
+    if (configuredIntervalRaw !== undefined) {
+        const parsed = Number(configuredIntervalRaw);
+        if (Number.isFinite(parsed) && parsed > 0)
+            configuredInterval = parsed;
+    }
+    const resolved = intervalMs ?? configuredInterval ?? ZED_POLL_INTERVAL_MS;
+    return Math.min(Math.max(resolved, ZED_POLL_INTERVAL_MS_MIN), ZED_POLL_INTERVAL_MS_MAX);
+}
+export function stopZedPolling(runtime) {
+    const fiber = runtime.zedPollFiber;
+    runtime.zedPollFiber = undefined;
+    runtime.zedPollIntervalMs = undefined;
+    if (fiber) {
+        Effect.runFork(Fiber.interrupt(fiber));
+    }
+    runtime.zedPollSelectionKey = undefined;
+    runtime.zedPollWalMtimeMs = undefined;
+}
+export function startZedPolling(runtime, ctx, options) {
+    const env = resolvePiConfigEnv(options?.env ?? process.env);
+    if (!isZedTerminal(env))
+        return false;
+    const dbPath = options?.dbPath ?? resolveZedDbPath(env);
+    if (!dbPath)
+        return false;
+    const intervalMs = resolveZedPollIntervalMs(env, options?.intervalMs);
+    const generation = options?.generation;
+    stopZedPolling(runtime);
+    runtime.connection?.disconnect();
+    runtime.connection = undefined;
+    runtime.currentCandidate = undefined;
+    runtime.connectionStatus = "connected";
+    runtime.connectedServer = { name: "Zed", ide: "zed" };
+    runtime.connectionMessage = undefined;
+    runtime.zedPollIntervalMs = intervalMs;
+    updateIdeUi(runtime, ctx);
+    const pollTick = () => {
+        if (generation !== undefined && runtime.sessionGeneration !== generation)
+            return "stop";
+        if (runtime.connection && runtime.connectedServer?.ide !== "zed")
+            return "stop";
+        const walPath = `${dbPath}-wal`;
+        let walMtimeMs;
+        try {
+            walMtimeMs = statSync(walPath).mtimeMs;
+        }
+        catch {
+        }
+        if (walMtimeMs !== undefined &&
+            runtime.zedPollWalMtimeMs !== undefined &&
+            walMtimeMs === runtime.zedPollWalMtimeMs) {
+            return "continue";
+        }
+        runtime.zedPollWalMtimeMs = walMtimeMs;
+        let snapshot;
+        try {
+            snapshot = resolveZedSelection({ dbPath, cwd: ctx.cwd, env });
+        }
+        catch {
+            snapshot = undefined;
+        }
+        if (snapshot) {
+            const key = snapshotKey(snapshot);
+            if (key !== runtime.zedPollSelectionKey) {
+                runtime.zedPollSelectionKey = key;
+                setLatestSelection(runtime, snapshot, ctx);
+            }
+        }
+        else {
+            clearLatestSelection(runtime, ctx);
+        }
+        return "continue";
+    };
+    const program = Effect.gen(function* () {
+        while (true) {
+            yield* Effect.sleep(`${intervalMs} millis`);
+            let outcome;
+            let pollError;
+            try {
+                outcome = pollTick();
+            }
+            catch (error) {
+                outcome = "error";
+                pollError = error;
+            }
+            if (outcome === "error") {
+                runtime.zedPollFiber = undefined;
+                runtime.zedPollIntervalMs = undefined;
+                runtime.zedPollSelectionKey = undefined;
+                runtime.zedPollWalMtimeMs = undefined;
+                containPiError(runtime, "Zed polling", pollError, ctx);
+                return;
+            }
+            if (outcome === "stop")
+                return;
+        }
+    });
+    const fiber = Effect.runFork(program.pipe(Effect.ensuring(Effect.sync(() => {
+        if (runtime.zedPollFiber === fiber) {
+            runtime.zedPollFiber = undefined;
+            runtime.zedPollIntervalMs = undefined;
+        }
+    }))));
+    runtime.zedPollFiber = fiber;
+    return true;
+}

package/dist/src/shared/config-options.js

@@ -0,0 +1,45 @@
+export const CONFIG_ENV_VALUE_TYPES = ["string", "number", "boolean"];
+export function isConfigEnvValue(value) {
+    return CONFIG_ENV_VALUE_TYPES.some((type) => typeof value === type);
+}
+export const CONFIG_ENV_OPTIONS = {
+    PI_X_IDE_AUTO_INSTALL: {
+        type: ["string", "number", "boolean"],
+        default: "enabled",
+        description: "Controls VS Code extension auto-install. Values 0, false, and off disable it.",
+    },
+    PI_X_IDE_ATTACH_SHORTCUT: {
+        type: ["string"],
+        default: "ctrl+alt+k",
+        description: "Pi TUI shortcut for attaching the latest IDE selection. Set to off, none, false, or 0 to disable.",
+    },
+    PI_X_IDE_HOST_OVERRIDE: {
+        type: ["string"],
+        description: "Override the host Pi uses to connect to IDE WebSocket lock files. Useful for WSL2 or custom networking.",
+    },
+    PI_X_IDE_ZED_DB: {
+        type: ["string"],
+        description: "Override path to Zed's SQLite database.",
+    },
+    PI_X_IDE_ZED_POLL_INTERVAL_MS: {
+        type: ["string", "number"],
+        description: "Polling interval in milliseconds when checking Zed's SQLite database for selection changes.",
+        default: "1000",
+    },
+};
+export const CONFIG_ENV_PATTERN_OPTIONS = [];
+export const STATUS_DISPLAY_VALUES = ["widget", "statusline"];
+export const DEFAULT_STATUS_DISPLAY = "widget";
+export const CONFIG_OPTIONS = {
+    fixPrompt: {
+        type: ["string"],
+        default: "Analyze the errors and warnings at the following location, and try to fix them:\n{DIAGNOSTIC}",
+        description: "Custom prompt prefix when requesting a fix for IDE diagnostics. Use {DIAGNOSTIC} as a placeholder for the diagnostic context. If the placeholder is omitted, the diagnostic context is appended after your prompt.",
+    },
+    status_display: {
+        type: ["string"],
+        default: DEFAULT_STATUS_DISPLAY,
+        enum: STATUS_DISPLAY_VALUES,
+        description: 'Where to show IDE connection status. Use "widget" for the above-editor widget (default), or "statusline" for the default footer status line.',
+    },
+};

package/dist/src/shared/config.js

@@ -0,0 +1,183 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { DEFAULT_STATUS_DISPLAY, isConfigEnvValue, STATUS_DISPLAY_VALUES, } from "./config-options.js";
+export const EXT_CONFIG_NAME = "pi-x-ide";
+export const CONFIG_DIR_NAME = ".pi";
+export const PI_CONFIG_FILE = "config.json";
+export const STATUS_DISPLAY_CONFIG_KEY = "status_display";
+export const AUTO_INSTALL_ENV_KEY = "PI_X_IDE_AUTO_INSTALL";
+const processEnvOverlays = new WeakSet();
+const AUTO_INSTALL_DISABLED_VALUES = new Set(["0", "false", "off"]);
+export function resolvePiConfigPath(home = homedir()) {
+    return resolvePiGlobalConfigPath(home);
+}
+export function resolvePiGlobalConfigPath(home = homedir()) {
+    return resolve(home, CONFIG_DIR_NAME, EXT_CONFIG_NAME, PI_CONFIG_FILE);
+}
+export function resolvePiProjectConfigPath(projectDir) {
+    return resolve(projectDir, CONFIG_DIR_NAME, EXT_CONFIG_NAME, PI_CONFIG_FILE);
+}
+export function readPiConfigFile(configPath) {
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(configPath, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+    return isRecord(parsed) ? parsed : undefined;
+}
+export 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)}\n`, "utf8");
+}
+export 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)]));
+}
+export function resolvePiConfigEnv(env = process.env, options = {}) {
+    if (env !== process.env && !options.configPath && options.projectDir === undefined) {
+        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;
+}
+export function isProcessEnvOrPiConfigOverlay(env) {
+    return env === process.env || processEnvOverlays.has(env);
+}
+export function readPiConfigFixPrompt(configPath = resolvePiConfigPath()) {
+    const parsed = readPiConfigFile(configPath);
+    if (!parsed)
+        return undefined;
+    return typeof parsed.fixPrompt === "string" ? parsed.fixPrompt : undefined;
+}
+export function readPiConfigStatusDisplay(configPathOrOptions = {}) {
+    return resolvePiConfigStatusDisplay(configPathOrOptions).value;
+}
+export function resolvePiConfigStatusDisplay(configPathOrOptions = {}) {
+    if (typeof configPathOrOptions === "string") {
+        const value = readStatusDisplayFromFile(configPathOrOptions);
+        return value === undefined
+            ? { 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 !== undefined) {
+            return { value: projectValue, scope: "project", path: projectPath };
+        }
+    }
+    const globalPath = resolvePiGlobalConfigPath(configPathOrOptions.home);
+    const globalValue = readStatusDisplayFromFile(globalPath);
+    if (globalValue !== undefined) {
+        return { value: globalValue, scope: "global", path: globalPath };
+    }
+    return { value: DEFAULT_STATUS_DISPLAY, scope: "default" };
+}
+export function resolvePiConfigAutoInstall(configPathOrOptions = {}) {
+    if (typeof configPathOrOptions === "string") {
+        const raw = readEnvValueFromFile(configPathOrOptions, AUTO_INSTALL_ENV_KEY);
+        return raw === undefined
+            ? { 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 !== undefined) {
+            return { value: parseAutoInstallValue(projectRaw), scope: "project", path: projectPath };
+        }
+    }
+    const globalPath = resolvePiGlobalConfigPath(configPathOrOptions.home);
+    const globalRaw = readEnvValueFromFile(globalPath, AUTO_INSTALL_ENV_KEY);
+    if (globalRaw !== undefined) {
+        return { value: parseAutoInstallValue(globalRaw), scope: "global", path: globalPath };
+    }
+    return { value: true, scope: "default" };
+}
+export function resolveIdeConfigSettings(options = {}) {
+    const display = resolvePiConfigStatusDisplay(options);
+    const autoInstall = resolvePiConfigAutoInstall(options);
+    return {
+        settings: {
+            display: display.value,
+            autoInstall: autoInstall.value,
+        },
+        display,
+        autoInstall,
+    };
+}
+export function writePiConfigStatusDisplay(value, options) {
+    return writePiConfigSettings({ display: value }, options);
+}
+export function writePiConfigSettings(settings, options) {
+    const path = options.scope === "project"
+        ? resolvePiProjectConfigPath(requireProjectDir(options.projectDir))
+        : resolvePiGlobalConfigPath(options.home);
+    const partial = {};
+    if (settings.display !== undefined) {
+        partial[STATUS_DISPLAY_CONFIG_KEY] = settings.display;
+    }
+    if (settings.autoInstall !== undefined) {
+        partial.env = {
+            [AUTO_INSTALL_ENV_KEY]: settings.autoInstall ? "true" : "false",
+        };
+    }
+    writePiConfigFile(partial, path);
+    return { path, scope: options.scope };
+}
+export 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 undefined;
+    const value = parsed[STATUS_DISPLAY_CONFIG_KEY];
+    return isStatusDisplay(value) ? value : undefined;
+}
+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);
+}