@zigai/pi-mode 0.3.1 → 0.4.1

package/src/settings.ts

@@ -1,323 +0,0 @@
-import {
-    getAgentDir,
-    SettingsManager,
-    type ExtensionContext,
-} from "@earendil-works/pi-coding-agent";
-import {
-    closeSync,
-    existsSync,
-    mkdirSync,
-    openSync,
-    readFileSync,
-    renameSync,
-    statSync,
-    unlinkSync,
-    writeFileSync,
-} from "node:fs";
-import { dirname, join } from "node:path";
-import { Type, type TSchema } from "typebox";
-import { Value } from "typebox/value";
-
-export const SHOW_MODE_NAME_SETTINGS_KEY = "modeShowName";
-export const USE_THINKING_BORDER_COLORS_SETTINGS_KEY = "modeUseThinkingBorderColors";
-
-const SETTINGS_LOCK_TIMEOUT_MS = 5_000;
-const STALE_SETTINGS_LOCK_MS = 30_000;
-const SettingsObjectSchema = Type.Object({});
-const BooleanSettingSchema = Type.Boolean();
-
-type SettingsReadContext = {
-    cwd: string;
-    projectTrusted: boolean;
-};
-
-let settingsReadContext: SettingsReadContext | undefined;
-let cachedSettings:
-    | {
-          mtimeKey: string;
-          showModeName: boolean;
-          useThinkingBorderColors: boolean;
-      }
-    | undefined;
-
-type ProjectTrustContext = ExtensionContext & {
-    isProjectTrusted?: () => boolean;
-};
-
-function isProjectTrusted(ctx: ExtensionContext): boolean {
-    return (ctx as ProjectTrustContext).isProjectTrusted?.() ?? true;
-}
-
-export function setSettingsContext(ctx: ExtensionContext): void {
-    const next: SettingsReadContext = {
-        cwd: ctx.cwd,
-        projectTrusted: isProjectTrusted(ctx),
-    };
-    if (
-        settingsReadContext?.cwd !== next.cwd ||
-        settingsReadContext.projectTrusted !== next.projectTrusted
-    ) {
-        settingsReadContext = next;
-        cachedSettings = undefined;
-    }
-}
-
-function getSettingsPath(): string {
-    return join(getAgentDir(), "settings.json");
-}
-
-function getProjectSettingsPath(): string | undefined {
-    if (settingsReadContext === undefined || !settingsReadContext.projectTrusted) {
-        return undefined;
-    }
-    return join(settingsReadContext.cwd, ".pi", "settings.json");
-}
-
-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 sleepSync(ms: number): void {
-    const buffer = new SharedArrayBuffer(4);
-    Atomics.wait(new Int32Array(buffer), 0, 0, ms);
-}
-
-function parseOptionalBoolean(schema: TSchema, value: unknown): boolean | undefined {
-    if (value === undefined) return undefined;
-    if (!Value.Check(schema, value)) return undefined;
-    const parsed: unknown = Value.Parse(schema, value);
-    if (typeof parsed === "boolean") return parsed;
-    return undefined;
-}
-
-function withSettingsLock<T>(settingsPath: string, fn: () => T): T {
-    const lockPath = `${settingsPath}.lock`;
-    mkdirSync(dirname(lockPath), { recursive: true });
-
-    const start = Date.now();
-    while (true) {
-        try {
-            const fd = openSync(lockPath, "wx");
-            try {
-                writeFileSync(
-                    fd,
-                    `${JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString() })}\n`,
-                    "utf8",
-                );
-            } catch {
-                // Ignore best-effort lock metadata.
-            }
-
-            try {
-                return fn();
-            } finally {
-                try {
-                    closeSync(fd);
-                } catch {
-                    // Ignore cleanup failures.
-                }
-                try {
-                    unlinkSync(lockPath);
-                } catch {
-                    // Ignore cleanup failures.
-                }
-            }
-        } catch (error: unknown) {
-            if (getErrorCode(error) !== "EEXIST") throwError(error);
-
-            try {
-                const stat = statSync(lockPath);
-                if (Date.now() - stat.mtimeMs > STALE_SETTINGS_LOCK_MS) {
-                    unlinkSync(lockPath);
-                    continue;
-                }
-            } catch {
-                // Ignore stale-lock checks.
-            }
-
-            if (Date.now() - start > SETTINGS_LOCK_TIMEOUT_MS) {
-                throw new Error(`Timed out waiting for lock: ${lockPath}`);
-            }
-            sleepSync(40 + Math.random() * 80);
-        }
-    }
-}
-
-function atomicWriteUtf8Sync(filePath: string, content: string): void {
-    mkdirSync(dirname(filePath), { recursive: true });
-
-    const tempPath = join(
-        dirname(filePath),
-        `.${filePath.split(/[\\/]/).pop() ?? "settings.json"}.tmp.${process.pid}.${Math.random()
-            .toString(16)
-            .slice(2)}`,
-    );
-
-    writeFileSync(tempPath, content, "utf8");
-
-    try {
-        renameSync(tempPath, filePath);
-    } catch (error: unknown) {
-        const code = getErrorCode(error);
-        if (code === "EEXIST" || code === "EPERM") {
-            try {
-                unlinkSync(filePath);
-            } catch {
-                // Ignore missing target before retrying the rename.
-            }
-            renameSync(tempPath, filePath);
-            return;
-        }
-        try {
-            unlinkSync(tempPath);
-        } catch {
-            // Ignore cleanup failures.
-        }
-        throwError(error);
-    }
-}
-
-function getFileMtimeMs(filePath: string | undefined): number | null {
-    if (filePath === undefined) return null;
-    try {
-        if (!existsSync(filePath)) return null;
-        return statSync(filePath).mtimeMs;
-    } catch {
-        return null;
-    }
-}
-
-function getSettingsMtimeKey(): string {
-    return `${getFileMtimeMs(getSettingsPath())}:${getFileMtimeMs(getProjectSettingsPath())}`;
-}
-
-function formatSchemaPath(instancePath: string): string {
-    if (instancePath.length === 0) return "root";
-    return instancePath
-        .slice(1)
-        .split("/")
-        .map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~"))
-        .join(".");
-}
-
-function parseSettingsObject(value: unknown, settingsPath: string): Record<string, unknown> {
-    const errors = [...Value.Errors(SettingsObjectSchema, value)];
-    if (errors.length > 0) {
-        const messages = errors
-            .slice(0, 5)
-            .map((error) => `${formatSchemaPath(error.instancePath)} ${error.message}`);
-        let suffix = "";
-        if (errors.length > messages.length) {
-            suffix = `; and ${errors.length - messages.length} more`;
-        }
-        throw new Error(
-            `${settingsPath} must contain a JSON object: ${messages.join("; ")}${suffix}`,
-        );
-    }
-    return { ...(Value.Parse(SettingsObjectSchema, value) as Record<string, unknown>) };
-}
-
-function readSettingsObject(options?: { throwOnInvalid?: boolean }): Record<string, unknown> {
-    const settingsPath = getSettingsPath();
-    try {
-        const raw = readFileSync(settingsPath, "utf8");
-        return parseSettingsObject(JSON.parse(raw), settingsPath);
-    } catch (error: unknown) {
-        if (getErrorCode(error) === "ENOENT") return {};
-        if (options?.throwOnInvalid === true) throwError(error);
-        // Ignore malformed settings files while reading and fall back to defaults.
-    }
-
-    return {};
-}
-
-function updateSettingsObject(update: (settings: Record<string, unknown>) => void): void {
-    const settingsPath = getSettingsPath();
-    withSettingsLock(settingsPath, () => {
-        const settings = readSettingsObject({ throwOnInvalid: true });
-        update(settings);
-        atomicWriteUtf8Sync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`);
-    });
-}
-
-function applyBooleanSetting(
-    settings: Record<string, unknown>,
-    key: string,
-    fallback: boolean,
-): boolean {
-    const parsed = parseOptionalBoolean(BooleanSettingSchema, settings[key]);
-    if (parsed === undefined) return fallback;
-    return parsed;
-}
-
-function readModeSettings(): {
-    showModeName: boolean;
-    useThinkingBorderColors: boolean;
-} {
-    const mtimeKey = getSettingsMtimeKey();
-    if (cachedSettings?.mtimeKey === mtimeKey) {
-        return cachedSettings;
-    }
-
-    const context = settingsReadContext ?? { cwd: process.cwd(), projectTrusted: false };
-    const manager = SettingsManager.create(context.cwd, getAgentDir(), {
-        projectTrusted: context.projectTrusted,
-    });
-    let showModeName = false;
-    let useThinkingBorderColors = false;
-
-    const globalSettings = manager.getGlobalSettings() as Record<string, unknown>;
-    showModeName = applyBooleanSetting(globalSettings, SHOW_MODE_NAME_SETTINGS_KEY, showModeName);
-    useThinkingBorderColors = applyBooleanSetting(
-        globalSettings,
-        USE_THINKING_BORDER_COLORS_SETTINGS_KEY,
-        useThinkingBorderColors,
-    );
-
-    const projectSettings = manager.getProjectSettings() as Record<string, unknown>;
-    showModeName = applyBooleanSetting(projectSettings, SHOW_MODE_NAME_SETTINGS_KEY, showModeName);
-    useThinkingBorderColors = applyBooleanSetting(
-        projectSettings,
-        USE_THINKING_BORDER_COLORS_SETTINGS_KEY,
-        useThinkingBorderColors,
-    );
-
-    cachedSettings = {
-        mtimeKey,
-        showModeName,
-        useThinkingBorderColors,
-    };
-    return cachedSettings;
-}
-
-export function shouldShowModeName(): boolean {
-    return readModeSettings().showModeName;
-}
-
-export function shouldUseThinkingBorderColors(): boolean {
-    return readModeSettings().useThinkingBorderColors;
-}
-
-export function setShowModeName(show: boolean): void {
-    updateSettingsObject((settings) => {
-        settings[SHOW_MODE_NAME_SETTINGS_KEY] = show;
-    });
-
-    cachedSettings = undefined;
-}
-
-export function setUseThinkingBorderColors(useThinkingBorderColors: boolean): void {
-    updateSettingsObject((settings) => {
-        settings[USE_THINKING_BORDER_COLORS_SETTINGS_KEY] = useThinkingBorderColors;
-    });
-
-    cachedSettings = undefined;
-}

package/src/storage.ts

@@ -1,128 +0,0 @@
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
-import fs from "node:fs/promises";
-import path from "node:path";
-
-export function getGlobalAgentDir(): string {
-    return getAgentDir();
-}
-
-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

@@ -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;
-};