@pi-archimedes/core 2.3.0 → 2.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-archimedes/core",
-  "version": "2.3.0",
+  "version": "2.5.0",
   "type": "module",
   "keywords": [
     "pi-package"
@@ -27,8 +27,8 @@
     "@earendil-works/pi-tui": ">=0.1.0"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "^0.84.2",
-    "@earendil-works/pi-tui": "^0.84.2",
+    "@earendil-works/pi-coding-agent": "^0.84.4",
+    "@earendil-works/pi-tui": "^0.84.4",
     "typescript": "^6.0.0"
   },
   "pi": {

package/src/bus.ts

@@ -108,7 +108,7 @@ export const Events = {
 
 interface TodoUpdatePayload {
   source: string;       // "main" or "subagent:<agent-name>"
-  todos: Array<{ id: number; title: string; description: string; status: "not-started" | "in-progress" | "completed" }>;
+  todos: Array<{ content: string; description?: string; status: "pending" | "in_progress" | "completed" }>;
 }
 
 interface TodoClearPayload {

package/src/index.ts

@@ -169,12 +169,15 @@ export function registerCore(pi: ExtensionAPI): void {
       });
     });
 
-    // Patch thinking renderer
-    patchThinkingRenderer(() => ctx.ui.theme);
-
-    // Load config for thinking transformation
+    // Load config for thinking transformation + label overrides
     const config = loadCoreConfig();
 
+    // Patch thinking renderer
+    patchThinkingRenderer(() => ctx.ui.theme, {
+      labelText: config.labelText,
+      labelColor: config.labelColor,
+    });
+
     // Register events
     pi.on("message_end", (event, _ctx) => {
       // Transform thinking content (unindent code blocks if enabled)

package/src/settings-io.test.ts

@@ -17,7 +17,148 @@ vi.mock("@earendil-works/pi-coding-agent", () => ({
 }));
 
 // Import after mocks are set up
-const { loadConfig, saveConfig } = await import("./settings-io.js");
+const { loadConfig, saveConfig, removeConfig, isConfigEnabled, setConfigEnabled } = await import("./settings-io.js");
+
+describe("removeConfig", () => {
+  beforeEach(() => {
+    const settingsPath = join(tempDir, "settings.json");
+    if (fs.existsSync(settingsPath)) {
+      fs.unlinkSync(settingsPath);
+    }
+  });
+
+  afterEach(() => {
+    const settingsPath = join(tempDir, "settings.json");
+    const tmpPath = settingsPath + ".tmp";
+    try { fs.unlinkSync(settingsPath); } catch { /* ignore */ }
+    try { fs.unlinkSync(tmpPath); } catch { /* ignore */ }
+  });
+
+  it("deletes an existing namespace key and leaves sibling keys intact", () => {
+    const settingsPath = join(tempDir, "settings.json");
+    fs.writeFileSync(
+      settingsPath,
+      JSON.stringify({ "test.ns": { foo: "bar" }, "other.ns": { baz: 1 }, "third.ns": { qux: "y" } }),
+      "utf-8",
+    );
+    removeConfig("test.ns");
+    const data = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+    expect(data["test.ns"]).toBeUndefined();
+    expect(data["other.ns"]).toEqual({ baz: 1 });
+    expect(data["third.ns"]).toEqual({ qux: "y" });
+    expect(fs.existsSync(settingsPath + ".tmp")).toBe(false);
+  });
+
+  it("is a no-op when the key is absent (no rewrite)", () => {
+    const settingsPath = join(tempDir, "settings.json");
+    fs.writeFileSync(
+      settingsPath,
+      JSON.stringify({ "other.ns": { baz: 1 } }),
+      "utf-8",
+    );
+    const beforeMtimeMs = fs.statSync(settingsPath).mtimeMs;
+    removeConfig("test.ns");
+    const afterMtimeMs = fs.statSync(settingsPath).mtimeMs;
+    expect(afterMtimeMs).toBe(beforeMtimeMs);
+    const data = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+    expect(data).toEqual({ "other.ns": { baz: 1 } });
+  });
+
+  it("does not create the file when settings.json does not exist", () => {
+    const settingsPath = join(tempDir, "settings.json");
+    expect(fs.existsSync(settingsPath)).toBe(false);
+    removeConfig("test.ns");
+    expect(fs.existsSync(settingsPath)).toBe(false);
+    expect(fs.existsSync(settingsPath + ".tmp")).toBe(false);
+  });
+});
+
+describe("isConfigEnabled", () => {
+  const settingsPath = () => join(tempDir, "settings.json");
+
+  beforeEach(() => {
+    if (fs.existsSync(settingsPath())) {
+      fs.unlinkSync(settingsPath());
+    }
+  });
+
+  afterEach(() => {
+    const path = settingsPath();
+    const tmpPath = path + ".tmp";
+    try { fs.unlinkSync(path); } catch { /* ignore */ }
+    try { fs.unlinkSync(tmpPath); } catch { /* ignore */ }
+  });
+
+  it("missing file/namespace → true", () => {
+    expect(isConfigEnabled("test.ns")).toBe(true);
+  });
+
+  it("empty namespace object → true", () => {
+    fs.writeFileSync(settingsPath(), JSON.stringify({ "test.ns": {} }), "utf-8");
+    expect(isConfigEnabled("test.ns")).toBe(true);
+  });
+
+  it("{ enabled: true } → true", () => {
+    fs.writeFileSync(settingsPath(), JSON.stringify({ "test.ns": { enabled: true } }), "utf-8");
+    expect(isConfigEnabled("test.ns")).toBe(true);
+  });
+
+  it("{ enabled: false } → false", () => {
+    fs.writeFileSync(settingsPath(), JSON.stringify({ "test.ns": { enabled: false } }), "utf-8");
+    expect(isConfigEnabled("test.ns")).toBe(false);
+  });
+
+  it("{ enabled: \"false\" } → true (strict === false check)", () => {
+    fs.writeFileSync(settingsPath(), JSON.stringify({ "test.ns": { enabled: "false" } }), "utf-8");
+    expect(isConfigEnabled("test.ns")).toBe(true);
+  });
+});
+
+describe("setConfigEnabled", () => {
+  const settingsPath = () => join(tempDir, "settings.json");
+
+  beforeEach(() => {
+    if (fs.existsSync(settingsPath())) {
+      fs.unlinkSync(settingsPath());
+    }
+  });
+
+  afterEach(() => {
+    const path = settingsPath();
+    const tmpPath = path + ".tmp";
+    try { fs.unlinkSync(path); } catch { /* ignore */ }
+    try { fs.unlinkSync(tmpPath); } catch { /* ignore */ }
+  });
+
+  it("set to false adds enabled:false, keeping other keys and sibling namespaces", () => {
+    fs.writeFileSync(
+      settingsPath(),
+      JSON.stringify({ "test.ns": { foo: "bar", count: 42 }, "other.ns": { baz: 1 } }),
+      "utf-8",
+    );
+    setConfigEnabled("test.ns", false);
+    const data = JSON.parse(fs.readFileSync(settingsPath(), "utf-8"));
+    expect(data["test.ns"]).toEqual({ foo: "bar", count: 42, enabled: false });
+    expect(data["other.ns"]).toEqual({ baz: 1 });
+    expect(isConfigEnabled("test.ns")).toBe(false);
+  });
+
+  it("set to true on { enabled: false } removes the namespace entirely (zero keys)", () => {
+    fs.writeFileSync(settingsPath(), JSON.stringify({ "test.ns": { enabled: false } }), "utf-8");
+    setConfigEnabled("test.ns", true);
+    const data = JSON.parse(fs.readFileSync(settingsPath(), "utf-8"));
+    expect(data["test.ns"]).toBeUndefined();
+    expect(isConfigEnabled("test.ns")).toBe(true);
+  });
+
+  it("set to true on { enabled: false, other: 1 } leaves the namespace as { other: 1 }", () => {
+    fs.writeFileSync(settingsPath(), JSON.stringify({ "test.ns": { enabled: false, other: 1 } }), "utf-8");
+    setConfigEnabled("test.ns", true);
+    const data = JSON.parse(fs.readFileSync(settingsPath(), "utf-8"));
+    expect(data["test.ns"]).toEqual({ other: 1 });
+    expect(isConfigEnabled("test.ns")).toBe(true);
+  });
+});
 
 describe("loadConfig", () => {
   beforeEach(() => {

package/src/settings-io.ts

@@ -40,3 +40,60 @@ export function saveConfig(namespace: string, config: object): void {
     writeFileSync(SETTINGS_PATH, JSON.stringify(full, null, 2), "utf-8");
   }
 }
+
+/**
+ * Delete a namespace section from settings.json entirely.
+ * No-op if the key is absent (including when the file doesn't exist — the file
+ * is never created). Atomic write, same pattern as saveConfig.
+ */
+export function removeConfig(namespace: string): void {
+  const full = readSettings();
+  // No file at all (readSettings returns {} for missing AND for corrupt,
+  // but only for missing is existsSync false) and no key → never create the file.
+  if (!existsSync(SETTINGS_PATH)) return;
+  if (!(namespace in full)) return;
+  delete full[namespace];
+  const tmpPath = SETTINGS_PATH + ".tmp";
+  writeFileSync(tmpPath, JSON.stringify(full, null, 2), "utf-8");
+  try {
+    renameSync(tmpPath, SETTINGS_PATH);
+  } catch {
+    try { unlinkSync(tmpPath); } catch { /* ignore */ }
+    writeFileSync(SETTINGS_PATH, JSON.stringify(full, null, 2), "utf-8");
+  }
+}
+
+/**
+ * True unless settings[namespace].enabled === false (strict comparison — a
+ * string "false" or 0 does NOT disable). Missing file/namespace/key ⇒ true.
+ */
+export function isConfigEnabled(namespace: string): boolean {
+  const cfg = loadConfig(namespace, {}) as { enabled?: boolean };
+  return cfg.enabled !== false;
+}
+
+/**
+ * Turn a namespace's `enabled` gate on or off without touching the
+ * namespace's other keys or sibling namespaces.
+ *
+ * off: write settings[ns].enabled = false (merged — other keys survive).
+ * on: delete the `enabled` key; if that leaves the namespace with zero keys,
+ * remove the whole namespace key from the file.
+ *
+ * A namespace omitted from settings.json counts as enabled.
+ */
+export function setConfigEnabled(namespace: string, enabled: boolean): void {
+  if (enabled) {
+    const cfg = loadConfig(namespace, {}) as Record<string, unknown>;
+    delete cfg.enabled;
+    if (Object.keys(cfg).length === 0) {
+      removeConfig(namespace);
+    } else {
+      saveConfig(namespace, cfg);
+    }
+  } else {
+    const cfg = loadConfig(namespace, {}) as Record<string, unknown>;
+    cfg.enabled = false;
+    saveConfig(namespace, cfg);
+  }
+}

package/src/thinking/patch.test.ts

@@ -272,4 +272,118 @@ describe("patchThinkingRenderer", () => {
 		// The patched function must be a new closure (not the same reference)
 		expect(MockClass.prototype.updateContent).not.toBe(first);
 	});
+
+	// ── Configurable thinking label (issue #36) ────────────────────────────
+
+	// Patches with a valid AssistantMessageComponent + mocked pi-tui so the
+	// Markdown content rendered for a thinking block can be inspected.
+	async function patchAndRender(
+		config?: { labelText?: string; labelColor?: string },
+		thinkingText = "Let me consider this carefully.",
+	) {
+		const MockClass = function AssistantMessageComponent() {};
+		MockClass.prototype.updateContent = function updateContent() {
+			if (this.content.type === "thinking") {
+				this.markdownTheme.codeBlockIndent = "";
+			}
+		};
+
+		vi.doMock("@earendil-works/pi-coding-agent", () => ({
+			AssistantMessageComponent: MockClass,
+			VERSION: "1.0.0",
+			highlightCode: vi.fn(),
+		}));
+
+		const capturedMarkdown: any[] = [];
+		class MockMarkdown {
+			content: string;
+			constructor(content: string, ..._rest: any[]) {
+				this.content = content;
+				capturedMarkdown.push(this);
+			}
+		}
+		class MockSpacer {}
+		class MockText {}
+		vi.doMock("@earendil-works/pi-tui", () => ({
+			Markdown: MockMarkdown,
+			Spacer: MockSpacer,
+			Text: MockText,
+		}));
+
+		vi.resetModules();
+		const mod = await import("./patch.js");
+		mod.patchThinkingRenderer(
+			() => ({ getFgAnsi: () => "", fg: (_t: string, text: string) => text }) as any,
+			config,
+		);
+
+		const instance = {
+			contentContainer: { clear: vi.fn(), addChild: vi.fn() },
+			isStreaming: false,
+			markdownTheme: { codeBlockIndent: "" },
+			markdownTransformers: [],
+			hideThinkingBlock: false,
+			outputPad: 1,
+		};
+		const message = {
+			content: [{ type: "thinking", thinking: thinkingText }],
+			stopReason: undefined,
+		};
+		MockClass.prototype.updateContent.call(instance, message, false);
+		return capturedMarkdown;
+	}
+
+	it("uses configured labelText/labelColor for the thinking label", async () => {
+		const captured = await patchAndRender({
+			labelText: "Yapping...",
+			labelColor: "255,215,0",
+		});
+
+		expect(captured).toHaveLength(1);
+		expect(
+			captured[0]!.content.startsWith("\x1b[1m\x1b[38;2;255;215;0mYapping...\x1b[39m\x1b[22m\n\n"),
+		).toBe(true);
+	});
+
+	it("defaults to the original Thinking... label when no config is given", async () => {
+		const captured = await patchAndRender();
+
+		expect(captured).toHaveLength(1);
+		// Byte-identical to the previous hardcoded THINKING_LABEL
+		expect(
+			captured[0]!.content.startsWith("\x1b[1m\x1b[38;2;255;215;0mThinking...\x1b[39m\x1b[22m\n\n"),
+		).toBe(true);
+	});
+
+	it("trims whitespace from configured labelText and labelColor", async () => {
+		const captured = await patchAndRender({
+			labelText: "  Yapping...  ",
+			labelColor: " 255, 215, 0 ",
+		});
+
+		expect(
+			captured[0]!.content.startsWith("\x1b[1m\x1b[38;2;255;215;0mYapping...\x1b[39m\x1b[22m\n\n"),
+		).toBe(true);
+	});
+
+	it("falls back to 255,215,0 when labelColor is not a valid RGB triple", async () => {
+		const captured = await patchAndRender({
+			labelText: "Hmm",
+			labelColor: "not-a-color",
+		});
+
+		expect(
+			captured[0]!.content.startsWith("\x1b[1m\x1b[38;2;255;215;0mHmm\x1b[39m\x1b[22m\n\n"),
+		).toBe(true);
+	});
+
+	it("does not double-prepend the label when content already starts with it", async () => {
+		const label = "\x1b[1m\x1b[38;2;255;215;0mYapping...\x1b[39m\x1b[22m";
+		const captured = await patchAndRender(
+			{ labelText: "Yapping...", labelColor: "255,215,0" },
+			`${label}\n\nAlready labelled body.`,
+		);
+
+		expect(captured[0]!.content).toBe(`${label}\n\nAlready labelled body.`);
+	});
 });

package/src/thinking/patch.ts

@@ -3,9 +3,6 @@ import { AssistantMessageComponent, VERSION } from "@earendil-works/pi-coding-ag
 import { Markdown, type MarkdownOptions, type MarkdownTheme, Spacer, Text } from "@earendil-works/pi-tui";
 import { buildMutedMarkdownTheme } from "./theme.js";
 
-// The label we prepend to visible thinking content.
-const THINKING_LABEL = "\x1b[1m\x1b[38;2;255;215;0mThinking...\x1b[39m\x1b[22m";
-
 // Track which pi version we patched against to detect incompatibility
 const PATCHED_KEY = Symbol.for("archimedes:thinkingPatched");
 const PATCH_VERSION_KEY = Symbol.for("archimedes:thinkingPatchVersion");
@@ -16,8 +13,15 @@ const PATCH_VERSION_KEY = Symbol.for("archimedes:thinkingPatchVersion");
  * to capture a fresh `getTheme` closure (required for /resume).
  *
  * Re-patches when pi version changes to catch breaking upstream changes.
+ *
+ * @param config Optional labelText/labelColor overrides for the thinking
+ *   block header. When omitted (or empty/invalid), the original defaults
+ *   ("Thinking..." / "255,215,0") are used, producing byte-identical output.
  */
-export function patchThinkingRenderer(getTheme: () => Theme): void {
+export function patchThinkingRenderer(
+  getTheme: () => Theme,
+  config?: { labelText?: string; labelColor?: string },
+): void {
   if (!AssistantMessageComponent) return;
 
   const proto = AssistantMessageComponent.prototype;
@@ -84,6 +88,21 @@ export function patchThinkingRenderer(getTheme: () => Theme): void {
     this.markdownTheme.codeBlockIndent = "";
     this.contentContainer.clear();
 
+    // Build the thinking-block header from the closure config once per render.
+    // Defaults preserve the original byte-identical output ("Thinking..." in
+    // bold truecolor 255,215,0).
+    const buildThinkingLabel = (): string => {
+      const label = config?.labelText?.trim() ? config.labelText.trim() : "Thinking...";
+      const color = config?.labelColor?.trim() ? config.labelColor.trim() : "255,215,0";
+      const parts = color.split(",").map((p) => p.trim());
+      // Valid iff exactly three 0..255 components (an "R,G,B" triple).
+      const valid =
+        parts.length === 3 &&
+        parts.every((p) => /^\d{1,3}$/.test(p) && Number(p) >= 0 && Number(p) <= 255);
+      const [r, g, b] = valid ? parts : ["255", "215", "0"];
+      return `\x1b[1m\x1b[38;2;${r};${g};${b}m${label}\x1b[39m\x1b[22m`;
+    };
+
     const hasVisibleContent = message.content.some(
       (c: any) =>
         (c.type === "text" && c.text.trim()) ||
@@ -202,8 +221,9 @@ export function patchThinkingRenderer(getTheme: () => Theme): void {
           }
         } else {
           let thinkingContent = thinkBlocks.join("\n\n");
-          if (!thinkingContent.startsWith(THINKING_LABEL)) {
-            thinkingContent = `${THINKING_LABEL}\n\n${thinkingContent}`;
+          const label = buildThinkingLabel();
+          if (!thinkingContent.startsWith(label)) {
+            thinkingContent = `${label}\n\n${thinkingContent}`;
           }
           const t = ensureTheme();
           if (!t) continue;

package/src/thinking/theme.ts

@@ -1,5 +1,8 @@
 import type { Theme } from "@earendil-works/pi-coding-agent";
-import { highlightCode as piHighlightCode } from "@earendil-works/pi-coding-agent";
+import {
+  highlightCode as piHighlightCode,
+  initTheme as piInitTheme,
+} from "@earendil-works/pi-coding-agent";
 import type { MarkdownTheme } from "@earendil-works/pi-tui";
 import {
   deriveDimColor,
@@ -23,6 +26,26 @@ const DEFAULT_CODE_DEFAULT_L = 0.85;
 // (bold/italic/reset/etc.) are left untouched.
 const FG_COLOR_ESCAPE_RE = /\x1b\[38;(?:2;\d{1,3};\d{1,3};\d{1,3}|5;\d{1,3})m/g;
 
+// pi 0.84.4's module-level `highlightCode` reads a *global* Theme
+// singleton that throws until `initTheme()` runs. pi's interactive
+// mode initializes it at startup, but contexts that build the muted
+// theme without going through that initialization (e.g. unit tests)
+// would otherwise get "Theme not initialized. Call initTheme() first."
+// We probe on first use and, only when the global is not set, call
+// `initTheme("dark")` — built-in theme, no file watcher attached.
+let piThemeReady = false;
+function ensurePiHighlightable(): void {
+  if (piThemeReady) return;
+  piThemeReady = true;
+  try {
+    piHighlightCode(""); // probe: throws when the global is unset
+  } catch (err) {
+    // Only fall back when the probe failed for the known reason, so an
+    // already-established pi theme is never clobbered by a surprise. 
+    if (String(err).includes("Theme not initialized")) piInitTheme("dark");
+  }
+}
+
 /**
  * Rewrite every foreground-color SGR escape in `line` to its dimmed truecolor
  * variant, preserving all other content (text, non-color escapes, resets).
@@ -114,6 +137,7 @@ export function buildMutedMarkdownTheme(
     strikethrough: (text) => `\x1b[9m${fg("dim", text)}\x1b[29m`,
     underline: (text) => `\x1b[4m${fg("thinkingText", text)}\x1b[24m`,
     highlightCode: (code, lang) => {
+      ensurePiHighlightable();
       const lines = piHighlightCode(code, lang);
       return lines.map((l) => {
         const dimmed = dimAnsiLine(l, anchorL, saturationFactor, dimCache);