@zigai/pi-mode 0.4.0 → 0.4.1

package/src/storage.ts

@@ -1,207 +0,0 @@
-import { CONFIG_DIR_NAME, getAgentDir } from "@earendil-works/pi-coding-agent";
-import fs from "node:fs/promises";
-import path from "node:path";
-
-export function getGlobalAgentDir(): string {
-    return getAgentDir();
-}
-
-const EXTENSION_ID = "pi-mode";
-const CONFIG_FILE = "config.json";
-const SCHEMA_FILE = "config.schema.json";
-
-const DEFAULT_MODES_CONFIG_FILE = {
-    $schema: `./${SCHEMA_FILE}`,
-    version: 1,
-    currentMode: "default",
-    modeShowName: false,
-    modeUseThinkingBorderColors: false,
-    modeShowThinkingLevelStatus: false,
-    modes: {},
-};
-
-export function getGlobalModesPath(): string {
-    return path.join(getGlobalAgentDir(), EXTENSION_ID, CONFIG_FILE);
-}
-
-export function getProjectModesPath(cwd: string): string {
-    return path.join(cwd, CONFIG_DIR_NAME, EXTENSION_ID, CONFIG_FILE);
-}
-
-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 });
-}
-
-function getSchemaPath(configPath: string): string {
-    return path.join(path.dirname(configPath), SCHEMA_FILE);
-}
-
-async function writeIfMissing(filePath: string, content: string): Promise<void> {
-    try {
-        await ensureDirForFile(filePath);
-        await fs.writeFile(filePath, content, { encoding: "utf8", flag: "wx" });
-    } catch (error: unknown) {
-        if (error instanceof Error && (error as NodeJS.ErrnoException).code === "EEXIST") return;
-        if (error instanceof Error) throw error;
-        throw new Error(String(error));
-    }
-}
-
-async function refreshSchemaFile(filePath: string, content: string): Promise<void> {
-    let temporaryPath: string | undefined;
-    try {
-        await ensureDirForFile(filePath);
-        try {
-            if ((await fs.readFile(filePath, "utf8")) === content) return;
-        } catch (error: unknown) {
-            if (!(error instanceof Error) || (error as NodeJS.ErrnoException).code !== "ENOENT") {
-                throw error;
-            }
-        }
-
-        const nextTemporaryPath = `${filePath}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-        await fs.writeFile(nextTemporaryPath, content, { encoding: "utf8", flag: "wx" });
-        temporaryPath = nextTemporaryPath;
-        await fs.rename(temporaryPath, filePath);
-        temporaryPath = undefined;
-    } catch (error: unknown) {
-        if (temporaryPath !== undefined) {
-            try {
-                await fs.unlink(temporaryPath);
-            } catch {
-                // Ignore cleanup failure while reporting the original scaffold failure.
-            }
-        }
-        if (error instanceof Error) throw error;
-        throw new Error(String(error));
-    }
-}
-
-async function readBundledSchema(): Promise<string | undefined> {
-    try {
-        return await fs.readFile(new URL("../config.schema.json", import.meta.url), "utf8");
-    } catch {
-        return undefined;
-    }
-}
-
-export async function scaffoldGlobalModesConfig(): Promise<void> {
-    const globalConfigPath = getGlobalModesPath();
-    const schema = await readBundledSchema();
-    if (schema !== undefined) {
-        await refreshSchemaFile(getSchemaPath(globalConfigPath), schema);
-    }
-    await writeIfMissing(
-        globalConfigPath,
-        `${JSON.stringify(DEFAULT_MODES_CONFIG_FILE, null, 2)}\n`,
-    );
-}
-
-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

@@ -1,55 +0,0 @@
-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 default editor border is used unless thinking-derived
-     * border colors are enabled in settings.
-     */
-    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;
-};