@zigai/pi-mode 0.1.3 → 0.2.0

package/README.md

@@ -1,11 +1,15 @@
 # Pi Mode
 
+[![npm version](https://img.shields.io/npm/v/@zigai/pi-mode.svg?color=blue)](https://www.npmjs.com/package/@zigai/pi-mode)
+[![npm downloads](https://img.shields.io/npm/dm/@zigai/pi-mode.svg)](https://www.npmjs.com/package/@zigai/pi-mode)
+[![license](https://img.shields.io/npm/l/@zigai/pi-mode.svg)](../../LICENSE)
+
 This Pi extension adds prompt modes for model and thinking-level switching.
 
 ## Install
 
 ```sh
-pi install git:github.com/zigai/pi-tweaks
+pi install npm:@zigai/pi-mode
 ```
 
 ## Features
@@ -18,4 +22,8 @@ pi install git:github.com/zigai/pi-tweaks
 
 Modes can store a provider, model, thinking level, and optional color. Project-local modes live in `.pi/modes.json` when present; otherwise global modes live in `~/.pi/agent/modes.json`.
 
-By default, Pi Mode does not print the mode name in the editor border. To opt in, toggle `Show mode name` from `/mode` → `Configure modes…`, or set `"modeShowName": true` in `~/.pi/agent/settings.json`.
+By default, Pi Mode does not print the mode name in the editor border. To opt in, toggle `Show mode name` from `/mode` → `Configure modes…`, or set `"modeShowName": true` in global `~/.pi/agent/settings.json` or trusted project `.pi/settings.json`. The `/mode` toggle writes to global settings.
+
+## License
+
+MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zigai/pi-mode",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "Pi package that adds prompt modes for model and thinking-level switching.",
   "keywords": [
     "mode",
@@ -29,6 +29,9 @@
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "typebox": "^1.1.38"
+  },
   "peerDependencies": {
     "@earendil-works/pi-agent-core": "*",
     "@earendil-works/pi-ai": "*",

package/src/index.ts

@@ -7,6 +7,7 @@ import {
     handleSessionActivated,
     selectModeUI,
 } from "./mode-state.ts";
+import { setSettingsContext } from "./settings.ts";
 
 export default function (pi: ExtensionAPI) {
     pi.registerCommand("mode", {
@@ -31,6 +32,7 @@ export default function (pi: ExtensionAPI) {
     });
 
     pi.on("session_start", async (_event, ctx) => {
+        setSettingsContext(ctx);
         await handleSessionActivated(pi, ctx);
         applyModeEditor(pi, ctx);
     });

package/src/mode-state.ts

@@ -7,6 +7,8 @@ import {
 import type { Api, Model } from "@earendil-works/pi-ai";
 import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
 import fs from "node:fs/promises";
+import { Type, type Static, type TSchema } from "typebox";
+import { Value } from "typebox/value";
 import {
     ALL_THINKING_LEVELS,
     CUSTOM_MODE_NAME,
@@ -34,17 +36,51 @@ type ScopedModelItem = {
     thinkingLevel?: string;
 };
 
-type ModeSpecJson = {
-    provider?: string;
-    modelId?: string;
-    thinkingLevel?: ThinkingLevel;
-    color?: ModeSpec["color"];
-};
+const ModeSpecJsonSchema = Type.Object({
+    provider: Type.Optional(Type.String()),
+    modelId: Type.Optional(Type.String()),
+    thinkingLevel: Type.Optional(Type.Unknown()),
+    color: Type.Optional(Type.String()),
+});
+
+const ModesFileJsonSchema = Type.Object({
+    $schema: Type.Optional(Type.String()),
+    version: Type.Optional(Type.Number()),
+    currentMode: Type.Optional(Type.String()),
+    modes: Type.Optional(Type.Record(Type.String(), ModeSpecJsonSchema)),
+});
+
+type ModeSpecJson = Static<typeof ModeSpecJsonSchema>;
+type ModesFileJson = Static<typeof ModesFileJsonSchema>;
+
+function formatSchemaPath(instancePath: string): string {
+    if (instancePath.length === 0) return "root";
+    return instancePath
+        .slice(1)
+        .split("/")
+        .map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~"))
+        .join(".");
+}
 
-type ModesFileJson = {
-    currentMode?: string;
-    modes?: Record<string, ModeSpecJson>;
-};
+function parseSchema(schema: TSchema, value: unknown, label: string): unknown {
+    const errors = [...Value.Errors(schema, 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(`${label} is invalid: ${messages.join("; ")}${suffix}`);
+    }
+    const parsed: unknown = Value.Parse(schema, value);
+    return parsed;
+}
+
+function parseModesFileJson(value: unknown): ModesFileJson {
+    return parseSchema(ModesFileJsonSchema, value, "modes.json") as ModesFileJson;
+}
 
 function cloneModesFile(file: ModesFile): ModesFile {
     return JSON.parse(JSON.stringify(file)) as ModesFile;
@@ -55,7 +91,7 @@ function modeSpec(modes: Record<string, ModeSpec>, name: string): ModeSpec | und
     return undefined;
 }
 
-function computeModesPatch(
+export function computeModesPatch(
     base: ModesFile,
     next: ModesFile,
     includeCurrentMode: boolean,
@@ -108,7 +144,7 @@ function computeModesPatch(
     return patch;
 }
 
-function applyModesPatch(target: ModesFile, patch: ModesPatch): void {
+export function applyModesPatch(target: ModesFile, patch: ModesPatch): void {
     if (patch.currentMode !== undefined) {
         target.currentMode = patch.currentMode;
     }
@@ -153,14 +189,30 @@ function applyModesPatch(target: ModesFile, patch: ModesPatch): void {
     }
 }
 
-function normalizeThinkingLevel(level: ThinkingLevel | undefined): ThinkingLevel | undefined {
-    if (level === undefined) return undefined;
-    if (ALL_THINKING_LEVELS.includes(level)) {
-        return level;
+function normalizeThinkingLevel(level: unknown): ThinkingLevel | undefined {
+    if (typeof level !== "string") return undefined;
+    if (ALL_THINKING_LEVELS.includes(level as ThinkingLevel)) {
+        return level as ThinkingLevel;
     }
     return undefined;
 }
 
+function getLoadErrorCode(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 errorMessage(error: unknown): string {
+    if (error instanceof Error) return error.message;
+    return String(error);
+}
+
+function throwLoadError(filePath: string, error: unknown): never {
+    throw new Error(`Failed to load ${filePath}: ${errorMessage(error)}`);
+}
+
 function sanitizeModeSpec(spec: ModeSpecJson | undefined): ModeSpec {
     if (spec === undefined) return {};
 
@@ -169,7 +221,7 @@ function sanitizeModeSpec(spec: ModeSpecJson | undefined): ModeSpec {
     };
     if (spec.provider !== undefined) sanitized.provider = spec.provider;
     if (spec.modelId !== undefined) sanitized.modelId = spec.modelId;
-    if (spec.color !== undefined) sanitized.color = spec.color;
+    if (spec.color !== undefined) sanitized.color = spec.color as ModeSpec["color"];
     return sanitized;
 }
 
@@ -225,10 +277,11 @@ async function loadModesFile(
     filePath: string,
     ctx: ExtensionContext,
     pi: ExtensionAPI,
+    options?: { throwOnInvalid?: boolean },
 ): Promise<ModesFile> {
     try {
         const raw = await fs.readFile(filePath, "utf8");
-        const parsed = JSON.parse(raw) as ModesFileJson;
+        const parsed = parseModesFileJson(JSON.parse(raw));
         const currentMode = parsed.currentMode ?? "default";
         const modesRaw = parsed.modes ?? {};
 
@@ -244,7 +297,9 @@ async function loadModesFile(
         };
         ensureDefaultModeEntries(file, ctx, pi);
         return file;
-    } catch {
+    } catch (error: unknown) {
+        if (getLoadErrorCode(error) === "ENOENT") return createDefaultModes(ctx, pi);
+        if (options?.throwOnInvalid === true) throwLoadError(filePath, error);
         return createDefaultModes(ctx, pi);
     }
 }
@@ -404,16 +459,23 @@ async function persistRuntime(pi: ExtensionAPI, ctx: ExtensionContext): Promise<
     const patch = computeModesPatch(runtime.baseline, runtime.data, false);
     if (patch === null) return;
 
-    await withFileLock(runtime.filePath, async () => {
-        const latest = await loadModesFile(runtime.filePath, ctx, pi);
-        applyModesPatch(latest, patch);
-        ensureDefaultModeEntries(latest, ctx, pi);
-        await saveModesFile(runtime.filePath, latest);
-
-        runtime.data = latest;
-        runtime.baseline = cloneModesFile(latest);
-        runtime.fileMtimeMs = await getMtimeMs(runtime.filePath);
-    });
+    try {
+        await withFileLock(runtime.filePath, async () => {
+            const latest = await loadModesFile(runtime.filePath, ctx, pi, { throwOnInvalid: true });
+            applyModesPatch(latest, patch);
+            ensureDefaultModeEntries(latest, ctx, pi);
+            await saveModesFile(runtime.filePath, latest);
+
+            runtime.data = latest;
+            runtime.baseline = cloneModesFile(latest);
+            runtime.fileMtimeMs = await getMtimeMs(runtime.filePath);
+        });
+    } catch (error: unknown) {
+        if (ctx.hasUI) {
+            ctx.ui.notify(`Mode settings were not saved: ${errorMessage(error)}`, "error");
+        }
+        throw error;
+    }
 }
 
 function getCurrentSelectionSpec(pi: ExtensionAPI): ModeSpec {
@@ -810,7 +872,12 @@ async function configureModesUI(pi: ExtensionAPI, ctx: ExtensionContext): Promis
 
         if (choice === MODE_UI_SHOW_NAME_ON || choice === MODE_UI_SHOW_NAME_OFF) {
             const next = !shouldShowModeName();
-            setShowModeName(next);
+            try {
+                setShowModeName(next);
+            } catch (error: unknown) {
+                ctx.ui.notify(`Mode name display was not saved: ${errorMessage(error)}`, "error");
+                continue;
+            }
             requestEditorRender?.();
             let displayState = "disabled";
             if (next) {

package/src/settings.ts

@@ -1,59 +1,278 @@
-import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
+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";
 
+const SETTINGS_LOCK_TIMEOUT_MS = 5_000;
+const STALE_SETTINGS_LOCK_MS = 30_000;
+const SettingsObjectSchema = Type.Object({});
+const ShowModeNameSchema = Type.Boolean();
+
+type SettingsReadContext = {
+    cwd: string;
+    projectTrusted: boolean;
+};
+
+let settingsReadContext: SettingsReadContext | undefined;
 let cachedShowModeName: boolean | undefined;
-let cachedSettingsMtimeMs: number | null | undefined;
+let cachedSettingsMtimeKey: string | 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;
+        cachedShowModeName = undefined;
+        cachedSettingsMtimeKey = undefined;
+    }
+}
 
 function getSettingsPath(): string {
-    return join(homedir(), ".pi", "agent", "settings.json");
+    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 getSettingsMtimeMs(): number | null {
+function getFileMtimeMs(filePath: string | undefined): number | null {
+    if (filePath === undefined) return null;
     try {
-        if (!existsSync(getSettingsPath())) return null;
-        return statSync(getSettingsPath()).mtimeMs;
+        if (!existsSync(filePath)) return null;
+        return statSync(filePath).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 };
+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`;
         }
-    } catch {
-        // Ignore malformed or missing settings files and fall back to defaults.
+        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 applyShowModeNameSetting(settings: Record<string, unknown>, fallback: boolean): boolean {
+    return (
+        parseOptionalBoolean(ShowModeNameSchema, settings[SHOW_MODE_NAME_SETTINGS_KEY]) ?? fallback
+    );
+}
+
 export function shouldShowModeName(): boolean {
-    const mtimeMs = getSettingsMtimeMs();
-    if (cachedShowModeName !== undefined && cachedSettingsMtimeMs === mtimeMs) {
+    const mtimeKey = getSettingsMtimeKey();
+    if (cachedShowModeName !== undefined && cachedSettingsMtimeKey === mtimeKey) {
         return cachedShowModeName;
     }
 
-    const settings = readSettingsObject();
-    cachedSettingsMtimeMs = mtimeMs;
-    cachedShowModeName = settings[SHOW_MODE_NAME_SETTINGS_KEY] === true;
+    const context = settingsReadContext ?? { cwd: process.cwd(), projectTrusted: false };
+    const manager = SettingsManager.create(context.cwd, getAgentDir(), {
+        projectTrusted: context.projectTrusted,
+    });
+    let show = false;
+    show = applyShowModeNameSetting(manager.getGlobalSettings() as Record<string, unknown>, show);
+    show = applyShowModeNameSetting(manager.getProjectSettings() as Record<string, unknown>, show);
+
+    cachedSettingsMtimeKey = mtimeKey;
+    cachedShowModeName = show;
     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");
+    updateSettingsObject((settings) => {
+        settings[SHOW_MODE_NAME_SETTINGS_KEY] = show;
+    });
 
-    cachedSettingsMtimeMs = getSettingsMtimeMs();
+    cachedSettingsMtimeKey = getSettingsMtimeKey();
     cachedShowModeName = show;
 }

package/src/storage.ts

@@ -1,17 +1,9 @@
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
 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");
+    return getAgentDir();
 }
 
 export function getGlobalModesPath(): string {