@zigai/pi-mode 0.1.4 → 0.3.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
@@ -14,8 +18,14 @@ pi install npm:@zigai/pi-mode
 - Adds `Ctrl+Shift+M` to select a mode.
 - Adds `Ctrl+Space` to cycle modes.
 - Can show the current mode in the prompt editor border when enabled.
-- Colors the prompt editor border from the active mode or thinking level.
+- Colors the prompt editor border from the active mode, with an opt-in setting for thinking-derived border colors.
 
 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.
+
+By default, Pi Mode uses the normal editor border color when the active mode does not define an explicit `color`. To opt in to thinking-derived border colors, toggle `Thinking border colors` from `/mode` → `Configure modes…`, or set `"modeUseThinkingBorderColors": true` in global `~/.pi/agent/settings.json` or trusted project `.pi/settings.json`. Explicit per-mode `color` values still apply.
+
+## License
+
+MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zigai/pi-mode",
-  "version": "0.1.4",
+  "version": "0.3.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/constants.ts

@@ -7,6 +7,8 @@ export const MODE_UI_CONFIGURE = "Configure modes…";
 export const MODE_UI_ADD = "Add mode…";
 export const MODE_UI_SHOW_NAME_ON = "Show mode name: on";
 export const MODE_UI_SHOW_NAME_OFF = "Show mode name: off";
+export const MODE_UI_THINKING_COLORS_ON = "Thinking border colors: on";
+export const MODE_UI_THINKING_COLORS_OFF = "Thinking border colors: off";
 export const MODE_UI_BACK = "Back";
 
 export const ALL_THINKING_LEVELS: ThinkingLevel[] = [

package/src/editor.ts

@@ -63,6 +63,7 @@ function enhanceEditor(
     requestRender: () => void,
 ): EditorLike {
     const originalRender = editor.render.bind(editor);
+    const defaultBorderColor = editor.borderColor;
     editor.render = (width: number) => modeLabelLine(originalRender(width), width, editor);
 
     const borderColor = (text: string) => {
@@ -70,7 +71,7 @@ function enhanceEditor(
         if (isBashMode) {
             return ctx.ui.theme.getBashModeBorderColor()(text);
         }
-        return getModeBorderColor(ctx, pi, getCurrentMode())(text);
+        return getModeBorderColor(ctx, pi, getCurrentMode(), defaultBorderColor)(text);
     };
 
     Object.defineProperty(editor, "borderColor", {

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,8 +32,12 @@ export default function (pi: ExtensionAPI) {
     });
 
     pi.on("session_start", async (_event, ctx) => {
-        await handleSessionActivated(pi, ctx);
+        setSettingsContext(ctx);
+        // Install the editor wrapper before loading mode files so startup renders use
+        // the configured border color immediately instead of briefly showing Pi's
+        // thinking-level border color.
         applyModeEditor(pi, ctx);
+        await handleSessionActivated(pi, ctx);
     });
 
     pi.on("model_select", async (event, 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,
@@ -16,6 +18,8 @@ import {
     MODE_UI_CONFIGURE,
     MODE_UI_SHOW_NAME_OFF,
     MODE_UI_SHOW_NAME_ON,
+    MODE_UI_THINKING_COLORS_OFF,
+    MODE_UI_THINKING_COLORS_ON,
     THINKING_UNSET_LABEL,
 } from "./constants.ts";
 import {
@@ -26,7 +30,12 @@ import {
     getProjectModesPath,
     withFileLock,
 } from "./storage.ts";
-import { setShowModeName, shouldShowModeName } from "./settings.ts";
+import {
+    setShowModeName,
+    setUseThinkingBorderColors,
+    shouldShowModeName,
+    shouldUseThinkingBorderColors,
+} from "./settings.ts";
 import type { ModeRuntime, ModesFile, ModesPatch, ModeSpec, ModeSpecPatch } from "./types.ts";
 
 type ScopedModelItem = {
@@ -34,17 +43,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 +98,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 +151,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 +196,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 +228,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 +288,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 ?? {};
 
@@ -367,6 +410,7 @@ export function getModeBorderColor(
     ctx: ExtensionContext,
     pi: ExtensionAPI,
     mode: string,
+    fallbackBorderColor?: (text: string) => string,
 ): (text: string) => string {
     const theme = ctx.ui.theme;
     const spec = runtime.data.modes[mode];
@@ -377,10 +421,15 @@ export function getModeBorderColor(
             theme.getFgAnsi(color);
             return (text: string) => theme.fg(color, text);
         } catch {
-            // fall back to thinking-derived colors
+            // fall through to the configured fallback border color
         }
     }
 
+    if (!shouldUseThinkingBorderColors()) {
+        if (fallbackBorderColor !== undefined) return fallbackBorderColor;
+        return (text: string) => theme.fg("borderMuted", text);
+    }
+
     return theme.getThinkingBorderColor(pi.getThinkingLevel());
 }
 
@@ -818,10 +867,15 @@ async function configureModesUI(pi: ExtensionAPI, ctx: ExtensionContext): Promis
         if (shouldShowModeName()) {
             showModeNameChoice = MODE_UI_SHOW_NAME_ON;
         }
+        let thinkingColorsChoice = MODE_UI_THINKING_COLORS_OFF;
+        if (shouldUseThinkingBorderColors()) {
+            thinkingColorsChoice = MODE_UI_THINKING_COLORS_ON;
+        }
         const choice = await ctx.ui.select("Configure modes", [
             ...names,
             MODE_UI_ADD,
             showModeNameChoice,
+            thinkingColorsChoice,
             MODE_UI_BACK,
         ]);
         if (choice === undefined || choice.length === 0 || choice === MODE_UI_BACK) return;
@@ -851,6 +905,26 @@ async function configureModesUI(pi: ExtensionAPI, ctx: ExtensionContext): Promis
             continue;
         }
 
+        if (choice === MODE_UI_THINKING_COLORS_ON || choice === MODE_UI_THINKING_COLORS_OFF) {
+            const next = !shouldUseThinkingBorderColors();
+            try {
+                setUseThinkingBorderColors(next);
+            } catch (error: unknown) {
+                ctx.ui.notify(
+                    `Thinking border colors were not saved: ${errorMessage(error)}`,
+                    "error",
+                );
+                continue;
+            }
+            requestEditorRender?.();
+            let displayState = "disabled";
+            if (next) {
+                displayState = "enabled";
+            }
+            ctx.ui.notify(`Thinking border colors ${displayState}`, "info");
+            continue;
+        }
+
         await editModeUI(pi, ctx, choice);
     }
 }
@@ -983,6 +1057,10 @@ export async function handleSessionActivated(
         runtime.currentMode = CUSTOM_MODE_NAME;
         customOverlay = getCurrentSelectionSpec(pi);
     }
+
+    if (ctx.hasUI) {
+        requestEditorRender?.();
+    }
 }
 
 export async function handleModelSelect(

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,64 @@ 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";
+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;
 
-let cachedShowModeName: boolean | undefined;
-let cachedSettingsMtimeMs: number | null | 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;
@@ -41,6 +90,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 +185,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,16 +248,62 @@ function updateSettingsObject(update: (settings: Record<string, unknown>) => voi
     });
 }
 
-export function shouldShowModeName(): boolean {
-    const mtimeMs = getSettingsMtimeMs();
-    if (cachedShowModeName !== undefined && cachedSettingsMtimeMs === mtimeMs) {
-        return cachedShowModeName;
+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 settings = readSettingsObject();
-    cachedSettingsMtimeMs = mtimeMs;
-    cachedShowModeName = settings[SHOW_MODE_NAME_SETTINGS_KEY] === true;
-    return cachedShowModeName;
+    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 {
@@ -183,6 +311,13 @@ export function setShowModeName(show: boolean): void {
         settings[SHOW_MODE_NAME_SETTINGS_KEY] = show;
     });
 
-    cachedSettingsMtimeMs = getSettingsMtimeMs();
-    cachedShowModeName = show;
+    cachedSettings = undefined;
+}
+
+export function setUseThinkingBorderColors(useThinkingBorderColors: boolean): void {
+    updateSettingsObject((settings) => {
+        settings[USE_THINKING_BORDER_COLORS_SETTINGS_KEY] = useThinkingBorderColors;
+    });
+
+    cachedSettings = undefined;
 }

package/src/types.ts

@@ -9,7 +9,8 @@ export type ModeSpec = {
     thinkingLevel?: ThinkingLevel;
     /**
      * Optional theme color token to use for the editor border.
-     * If unset, the border color is derived from the current thinking level.
+     * If unset, the default editor border is used unless thinking-derived
+     * border colors are enabled in settings.
      */
     color?: ThemeColor;
 };