@zigai/pi-mode 0.1.2

package/src/settings.ts

@@ -0,0 +1,59 @@
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+export const SHOW_MODE_NAME_SETTINGS_KEY = "modeShowName";
+
+let cachedShowModeName: boolean | undefined;
+let cachedSettingsMtimeMs: number | null | undefined;
+
+function getSettingsPath(): string {
+    return join(homedir(), ".pi", "agent", "settings.json");
+}
+
+function getSettingsMtimeMs(): number | null {
+    try {
+        if (!existsSync(getSettingsPath())) return null;
+        return statSync(getSettingsPath()).mtimeMs;
+    } catch {
+        return null;
+    }
+}
+
+function readSettingsObject(): Record<string, unknown> {
+    try {
+        const raw = readFileSync(getSettingsPath(), "utf8");
+        const parsed = JSON.parse(raw) as unknown;
+        if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return { ...parsed };
+        }
+    } catch {
+        // Ignore malformed or missing settings files and fall back to defaults.
+    }
+
+    return {};
+}
+
+export function shouldShowModeName(): boolean {
+    const mtimeMs = getSettingsMtimeMs();
+    if (cachedShowModeName !== undefined && cachedSettingsMtimeMs === mtimeMs) {
+        return cachedShowModeName;
+    }
+
+    const settings = readSettingsObject();
+    cachedSettingsMtimeMs = mtimeMs;
+    cachedShowModeName = settings[SHOW_MODE_NAME_SETTINGS_KEY] === true;
+    return cachedShowModeName;
+}
+
+export function setShowModeName(show: boolean): void {
+    const settingsPath = getSettingsPath();
+    const settings = readSettingsObject();
+    settings[SHOW_MODE_NAME_SETTINGS_KEY] = show;
+
+    mkdirSync(dirname(settingsPath), { recursive: true });
+    writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
+
+    cachedSettingsMtimeMs = getSettingsMtimeMs();
+    cachedShowModeName = show;
+}

package/src/storage.ts

@@ -0,0 +1,136 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+export function expandUserPath(value: string): string {
+    if (value === "~") return os.homedir();
+    if (value.startsWith("~/")) return path.join(os.homedir(), value.slice(2));
+    return value;
+}
+
+export function getGlobalAgentDir(): string {
+    const env = process.env.PI_CODING_AGENT_DIR;
+    if (env !== undefined && env.length > 0) return expandUserPath(env);
+    return path.join(os.homedir(), ".pi", "agent");
+}
+
+export function getGlobalModesPath(): string {
+    return path.join(getGlobalAgentDir(), "modes.json");
+}
+
+export function getProjectModesPath(cwd: string): string {
+    return path.join(cwd, ".pi", "modes.json");
+}
+
+export async function fileExists(filePath: string): Promise<boolean> {
+    try {
+        await fs.stat(filePath);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+export async function ensureDirForFile(filePath: string): Promise<void> {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+}
+
+export async function getMtimeMs(filePath: string): Promise<number | null> {
+    try {
+        const stat = await fs.stat(filePath);
+        return stat.mtimeMs;
+    } catch {
+        return null;
+    }
+}
+
+function sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function getErrorCode(error: unknown): string | undefined {
+    if (!(error instanceof Error)) return undefined;
+    const code = (error as NodeJS.ErrnoException).code;
+    if (typeof code === "string") return code;
+    return undefined;
+}
+
+function throwError(error: unknown): never {
+    if (error instanceof Error) throw error;
+    throw new Error(String(error));
+}
+
+function getLockPathForFile(filePath: string): string {
+    return `${filePath}.lock`;
+}
+
+export async function withFileLock<T>(filePath: string, fn: () => Promise<T>): Promise<T> {
+    const lockPath = getLockPathForFile(filePath);
+    await ensureDirForFile(lockPath);
+
+    const start = Date.now();
+    while (true) {
+        try {
+            const handle = await fs.open(lockPath, "wx");
+            try {
+                await handle.writeFile(
+                    JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString() }) +
+                        "\n",
+                    "utf8",
+                );
+            } catch {
+                // ignore best-effort lock metadata
+            }
+
+            try {
+                return await fn();
+            } finally {
+                await handle.close().catch(() => {});
+                await fs.unlink(lockPath).catch(() => {});
+            }
+        } catch (error: unknown) {
+            if (getErrorCode(error) !== "EEXIST") throwError(error);
+
+            try {
+                const stat = await fs.stat(lockPath);
+                if (Date.now() - stat.mtimeMs > 30_000) {
+                    await fs.unlink(lockPath);
+                    continue;
+                }
+            } catch {
+                // ignore stale-lock checks
+            }
+
+            if (Date.now() - start > 5_000) {
+                throw new Error(`Timed out waiting for lock: ${lockPath}`);
+            }
+            await sleep(40 + Math.random() * 80);
+        }
+    }
+}
+
+export async function atomicWriteUtf8(filePath: string, content: string): Promise<void> {
+    await ensureDirForFile(filePath);
+
+    const dir = path.dirname(filePath);
+    const base = path.basename(filePath);
+    const tempPath = path.join(
+        dir,
+        `.${base}.tmp.${process.pid}.${Math.random().toString(16).slice(2)}`,
+    );
+
+    await fs.writeFile(tempPath, content, "utf8");
+
+    try {
+        await fs.rename(tempPath, filePath);
+    } catch (error: unknown) {
+        const code = getErrorCode(error);
+        if (code === "EEXIST" || code === "EPERM") {
+            await fs.unlink(filePath).catch(() => {});
+            await fs.rename(tempPath, filePath);
+        } else {
+            await fs.unlink(tempPath).catch(() => {});
+            throwError(error);
+        }
+    }
+}

package/src/types.ts

@@ -0,0 +1,54 @@
+import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
+import type { ThemeColor } from "@earendil-works/pi-coding-agent";
+
+export type ModeName = string;
+
+export type ModeSpec = {
+    provider?: string;
+    modelId?: string;
+    thinkingLevel?: ThinkingLevel;
+    /**
+     * Optional theme color token to use for the editor border.
+     * If unset, the border color is derived from the current thinking level.
+     */
+    color?: ThemeColor;
+};
+
+export type ModesFile = {
+    version: 1;
+    currentMode: ModeName;
+    modes: Record<ModeName, ModeSpec>;
+};
+
+export type ModeSpecPatch = {
+    provider?: string | null;
+    modelId?: string | null;
+    thinkingLevel?: ThinkingLevel | null;
+    color?: ThemeColor | null;
+};
+
+export type ModesPatch = {
+    currentMode?: ModeName;
+    modes?: Record<ModeName, ModeSpecPatch | null>;
+};
+
+export type ModeRuntime = {
+    filePath: string;
+    fileMtimeMs: number | null;
+    /**
+     * Snapshot of what we last loaded or synced from disk. Used to compute patches
+     * so multiple running pi processes do not clobber each other's edits.
+     */
+    baseline: ModesFile | null;
+    data: ModesFile;
+    /**
+     * Last non-overlay mode. Used as cycle base while in the overlay custom mode.
+     */
+    lastRealMode: string;
+    /**
+     * The effective current mode. Can temporarily be the overlay custom mode,
+     * which is not persisted and not selectable via /mode.
+     */
+    currentMode: string;
+    applying: boolean;
+};