@zigai/pi-mode 0.1.4 → 0.2.0

package/README.md

@@ -1,5 +1,9 @@
 # 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
@@ -18,4 +22,8 @@ pi install npm:@zigai/pi-mode
 
 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.4",
+  "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,10 +189,10 @@ 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;
 }
@@ -185,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;
 }
 
@@ -245,7 +281,7 @@ async function loadModesFile(
 ): 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 ?? {};
 

package/src/settings.ts

@@ -1,4 +1,8 @@
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import {
+    getAgentDir,
+    SettingsManager,
+    type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
 import {
     closeSync,
     existsSync,
@@ -11,19 +15,59 @@ import {
     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(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;
@@ -41,6 +85,14 @@ function sleepSync(ms: number): void {
     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 });
@@ -128,26 +180,51 @@ function atomicWriteUtf8Sync(filePath: string, content: string): void {
     }
 }
 
-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 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");
-        const parsed = JSON.parse(raw) as unknown;
-        if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
-            return { ...parsed };
-        }
-        if (options?.throwOnInvalid === true) {
-            throw new Error(`${settingsPath} must contain a JSON object.`);
-        }
+        return parseSettingsObject(JSON.parse(raw), settingsPath);
     } catch (error: unknown) {
         if (getErrorCode(error) === "ENOENT") return {};
         if (options?.throwOnInvalid === true) throwError(error);
@@ -166,15 +243,28 @@ function updateSettingsObject(update: (settings: Record<string, unknown>) => voi
     });
 }
 
+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;
 }
 
@@ -183,6 +273,6 @@ export function setShowModeName(show: boolean): void {
         settings[SHOW_MODE_NAME_SETTINGS_KEY] = show;
     });
 
-    cachedSettingsMtimeMs = getSettingsMtimeMs();
+    cachedSettingsMtimeKey = getSettingsMtimeKey();
     cachedShowModeName = show;
 }