@pi-archimedes/ui 2.9.0

package/src/index.test.ts

@@ -0,0 +1,402 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+  Theme,
+  KeybindingsManager,
+} from "@earendil-works/pi-coding-agent";
+import type { TUI, EditorTheme, Component } from "@earendil-works/pi-tui";
+
+// ── Mock modules ─────────────────────────────────────────────────────────────
+
+vi.mock("@pi-archimedes/core/settings-io", () => ({
+  loadConfig: vi.fn(),
+  saveConfig: vi.fn(),
+  removeConfig: vi.fn(),
+}));
+
+vi.mock("./config.js", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("./config.js")>();
+  return {
+    ...actual,
+    loadUIConfig: vi.fn(),
+  };
+});
+
+vi.mock("./startup/capture.js", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("./startup/capture.js")>();
+  return {
+    ...actual,
+    patchConsoleLog: vi.fn(),
+    unpatchConsoleLog: vi.fn(),
+  };
+});
+
+vi.mock("./thinking/patch.js", () => ({
+  patchThinkingRenderer: vi.fn(),
+}));
+
+vi.mock("./thinking/transform.js", () => ({
+  transformThinkingContent: vi.fn(),
+}));
+
+vi.mock("./startup/index.js", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("./startup/index.js")>();
+  return {
+    ...actual,
+    renderHeader: vi.fn(() => ["header line"]),
+    patchStartupListing: vi.fn(),
+  };
+});
+
+vi.mock("./migration.js", () => ({
+  migrateCoreToUIConfig: vi.fn(),
+  migrateCompactThinkingToStyle: vi.fn(),
+  migrateRemovedToolPatch: vi.fn(),
+  UI_CONFIG_KEYS: [],
+}));
+
+vi.mock("./bash/index.js", () => ({
+  registerBashToolOverride: vi.fn(),
+  clearActiveBashIntervals: vi.fn(),
+}));
+
+vi.mock("./codemode/index.js", () => ({
+  registerCodemodeToolOverride: vi.fn(async () => true),
+  clearActiveCodemodeIntervals: vi.fn(),
+}));
+
+import defaultExport, {
+  registerUI,
+  unpatchConsoleLog,
+  getUISettingsItems,
+  loadUIConfig,
+  saveUIConfig,
+  DEFAULT_UI_CONFIG,
+  ANIMATION_STYLES,
+} from "./index.js";
+import { patchConsoleLog } from "./startup/capture.js";
+import { migrateCoreToUIConfig } from "./migration.js";
+import { registerBashToolOverride, clearActiveBashIntervals } from "./bash/index.js";
+import { registerCodemodeToolOverride, clearActiveCodemodeIntervals } from "./codemode/index.js";
+import { patchThinkingRenderer } from "./thinking/patch.js";
+import { transformThinkingContent } from "./thinking/transform.js";
+import { renderHeader, patchStartupListing } from "./startup/index.js";
+
+// ── Test helpers ─────────────────────────────────────────────────────────────
+
+interface UiSpies {
+  setHeader: ReturnType<typeof vi.fn>;
+  setEditorComponent: ReturnType<typeof vi.fn>;
+  setWorkingVisible: ReturnType<typeof vi.fn>;
+}
+
+function makeCtx(hasUI = true): { ctx: ExtensionContext; ui: UiSpies } {
+  const ui: UiSpies = {
+    setHeader: vi.fn(),
+    setEditorComponent: vi.fn(),
+    setWorkingVisible: vi.fn(),
+  };
+  const ctx = {
+    hasUI,
+    cwd: "/workspace/test-project",
+    ui: { ...ui, theme: {} as Theme },
+    isIdle: vi.fn(() => true),
+    shutdown: vi.fn(),
+  } as unknown as ExtensionContext;
+  return { ctx, ui };
+}
+
+function setupHarness(): {
+  pi: ExtensionAPI;
+  triggerStart: (ctx: ExtensionContext) => void;
+  triggerShutdown: (ctx: ExtensionContext) => void;
+  triggerMessageEnd: (msg: unknown) => void;
+} {
+  const listeners: Record<string, ((event: any, ctx: any) => void)[]> = {};
+  const pi = {
+    on: vi.fn((event: string, handler: (event: any, ctx: any) => void) => {
+      listeners[event] = listeners[event] ?? [];
+      listeners[event]!.push(handler);
+    }),
+    registerTool: vi.fn(),
+  } as unknown as ExtensionAPI;
+
+  registerUI(pi);
+
+  return {
+    pi,
+    triggerStart: (ctx: ExtensionContext) => {
+      for (const h of listeners["session_start"] ?? []) {
+        h(null, ctx);
+      }
+    },
+    triggerShutdown: (ctx: ExtensionContext) => {
+      for (const h of listeners["session_shutdown"] ?? []) {
+        h(null, ctx);
+      }
+    },
+    triggerMessageEnd: (msg: unknown) => {
+      for (const h of listeners["message_end"] ?? []) {
+        h({ message: msg }, {} as any);
+      }
+    },
+  };
+}
+
+describe("packages/ui lifecycle and registration", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(loadUIConfig).mockReturnValue({ ...DEFAULT_UI_CONFIG });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("exports", () => {
+    it("re-exports expected functions and constants", () => {
+      expect(typeof unpatchConsoleLog).toBe("function");
+      expect(typeof getUISettingsItems).toBe("function");
+      expect(typeof loadUIConfig).toBe("function");
+      expect(typeof saveUIConfig).toBe("function");
+      expect(DEFAULT_UI_CONFIG).toBeDefined();
+      expect(ANIMATION_STYLES).toBeDefined();
+      expect(typeof defaultExport).toBe("function");
+    });
+
+    it("default export delegates to registerUI", () => {
+      const pi = { on: vi.fn() } as unknown as ExtensionAPI;
+      defaultExport(pi);
+      expect(migrateCoreToUIConfig).toHaveBeenCalled();
+      expect(patchConsoleLog).toHaveBeenCalled();
+    });
+  });
+
+  describe("registerUI initialization", () => {
+    it("calls migrateCoreToUIConfig and patchConsoleLog", () => {
+      const { pi } = setupHarness();
+      expect(migrateCoreToUIConfig).toHaveBeenCalledTimes(1);
+      expect(patchConsoleLog).toHaveBeenCalledTimes(1);
+      expect(pi.on).toHaveBeenCalledWith("session_shutdown", expect.any(Function));
+      expect(pi.on).toHaveBeenCalledWith("session_start", expect.any(Function));
+    });
+  });
+
+  describe("session_start with interactive UI (hasUI: true)", () => {
+    it("configures bash tool override, codemode tool override, header, editor, and thinking renderer", () => {
+      const { triggerStart } = setupHarness();
+      const { ctx, ui } = makeCtx(true);
+
+      triggerStart(ctx);
+
+      // Bash tool override
+      expect(registerBashToolOverride).toHaveBeenCalledWith(expect.anything(), "/workspace/test-project");
+
+      // Codemode tool override (fire-and-forget)
+      expect(registerCodemodeToolOverride).toHaveBeenCalledWith(expect.anything());
+
+      // Header installation
+      expect(ui.setHeader).toHaveBeenCalledTimes(1);
+      const headerFactory = ui.setHeader.mock.calls[0]![0];
+      const fakeTui = { terminal: { rows: 24 } } as TUI;
+      const fakeTheme = {} as Theme;
+      const comp = headerFactory(fakeTui, fakeTheme);
+      expect(typeof comp.render).toBe("function");
+      comp.render(80);
+      expect(renderHeader).toHaveBeenCalledWith(fakeTheme, expect.any(Object), 80, 21);
+      expect(patchStartupListing).toHaveBeenCalledWith(fakeTui, fakeTheme, expect.any(Object));
+
+      // Working visibility and Editor component
+      expect(ui.setWorkingVisible).toHaveBeenCalledWith(false); // spinFlag is true by default
+      expect(ui.setEditorComponent).toHaveBeenCalledTimes(1);
+      const editorFactory = ui.setEditorComponent.mock.calls[0]![0];
+      const editorInstance = editorFactory(fakeTui, { borderColor: (s: string) => s } as EditorTheme, {} as KeybindingsManager);
+      expect(editorInstance).toBeDefined();
+      (editorInstance as any).dispose?.();
+
+      // Thinking renderer
+      expect(patchThinkingRenderer).toHaveBeenCalledWith(
+        expect.any(Function),
+        expect.objectContaining({
+          labelText: "Thinking...",
+          labelColor: "255,215,0",
+          autoCollapseThinking: false,
+          thinkingStyle: "Full",
+        }),
+      );
+
+      // Master gate (default toolStyle is Minimal): both overrides registered
+      expect(registerBashToolOverride).toHaveBeenCalled();
+      expect(registerCodemodeToolOverride).toHaveBeenCalled();
+    });
+
+    it("skips the tool overrides entirely when toolStyle is Native", () => {
+      vi.mocked(loadUIConfig).mockReturnValue({
+        ...DEFAULT_UI_CONFIG,
+        toolStyle: "Native",
+      });
+
+      const { triggerStart } = setupHarness();
+      const { ctx, ui } = makeCtx(true);
+
+      triggerStart(ctx);
+
+      // Native = no archimedes tool styling: neither override is registered
+      // (pi's native rendering stands, no built-in-takeover notice).
+      expect(registerBashToolOverride).not.toHaveBeenCalled();
+      expect(registerCodemodeToolOverride).not.toHaveBeenCalled();
+      // The rest of the UI still comes up.
+      expect(ui.setHeader).toHaveBeenCalledTimes(1);
+    });
+
+    it("respects editorSpinBorder: false by leaving workingVisible=true and not installing editor component", () => {
+      vi.mocked(loadUIConfig).mockReturnValue({
+        ...DEFAULT_UI_CONFIG,
+        editorSpinBorder: false,
+      });
+
+      const { triggerStart } = setupHarness();
+      const { ctx, ui } = makeCtx(true);
+
+      triggerStart(ctx);
+
+      expect(ui.setWorkingVisible).toHaveBeenCalledWith(true);
+      expect(ui.setEditorComponent).not.toHaveBeenCalled();
+    });
+
+    it("skips bashToolOverride when bashToolStyling is false", () => {
+      vi.mocked(loadUIConfig).mockReturnValue({
+        ...DEFAULT_UI_CONFIG,
+        bashToolStyling: false,
+      });
+
+      const { triggerStart } = setupHarness();
+      const { ctx } = makeCtx(true);
+
+      triggerStart(ctx);
+
+      expect(registerBashToolOverride).not.toHaveBeenCalled();
+    });
+
+    it("skips the codemode tool override when codemodeToolStyling is false", () => {
+      vi.mocked(loadUIConfig).mockReturnValue({
+        ...DEFAULT_UI_CONFIG,
+        codemodeToolStyling: false,
+      });
+
+      const { triggerStart } = setupHarness();
+      const { ctx } = makeCtx(true);
+
+      triggerStart(ctx);
+
+      expect(registerCodemodeToolOverride).not.toHaveBeenCalled();
+    });
+
+    it("does not accumulate message_end listeners on repeated session_start (simulating /reload)", () => {
+      vi.mocked(loadUIConfig).mockReturnValue({
+        ...DEFAULT_UI_CONFIG,
+        codeUnindent: true,
+      });
+
+      const { triggerStart, triggerMessageEnd } = setupHarness();
+      const { ctx } = makeCtx(true);
+
+      triggerStart(ctx);
+      triggerStart(ctx); // Simulate second session_start
+
+      const msg = { role: "assistant", content: [] };
+      triggerMessageEnd(msg);
+
+      expect(transformThinkingContent).toHaveBeenCalledTimes(1);
+    });
+
+    it("skips transformThinkingContent on message_end if codeUnindent is false", () => {
+      vi.mocked(loadUIConfig).mockReturnValue({
+        ...DEFAULT_UI_CONFIG,
+        codeUnindent: false,
+      });
+
+      const { triggerStart, triggerMessageEnd } = setupHarness();
+      const { ctx } = makeCtx(true);
+
+      triggerStart(ctx);
+
+      const msg = { role: "assistant", content: [] };
+      triggerMessageEnd(msg);
+
+      expect(transformThinkingContent).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("session_start in non-interactive mode (hasUI: false)", () => {
+    it("still registers bashToolOverride but skips UI setup", () => {
+      const { triggerStart } = setupHarness();
+      const { ctx, ui } = makeCtx(false);
+
+      triggerStart(ctx);
+
+      expect(registerBashToolOverride).toHaveBeenCalledWith(expect.anything(), "/workspace/test-project");
+      expect(ui.setHeader).not.toHaveBeenCalled();
+      expect(ui.setEditorComponent).not.toHaveBeenCalled();
+      expect(patchThinkingRenderer).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("session_shutdown teardown", () => {
+    it("restores unpatchConsoleLog, workingVisible, and clears editor component", () => {
+      const { triggerStart, triggerShutdown } = setupHarness();
+      const { ctx, ui } = makeCtx(true);
+
+      triggerStart(ctx);
+
+      // Verify startup
+      expect(ui.setWorkingVisible).toHaveBeenCalledWith(false);
+
+      // Now trigger shutdown
+      triggerShutdown(ctx);
+
+      expect(unpatchConsoleLog).toHaveBeenCalledTimes(1);
+      expect(clearActiveBashIntervals).toHaveBeenCalledTimes(1);
+      expect(clearActiveCodemodeIntervals).toHaveBeenCalledTimes(1);
+      expect(ui.setWorkingVisible).toHaveBeenLastCalledWith(true);
+      expect(ui.setEditorComponent).toHaveBeenLastCalledWith(undefined);
+    });
+
+    it("cleans up patched TUI container children on shutdown", () => {
+      const { triggerStart, triggerShutdown } = setupHarness();
+      const { ctx, ui } = makeCtx(true);
+
+      triggerStart(ctx);
+
+      const headerFactory = ui.setHeader.mock.calls[0]![0];
+      const PATCHED_LISTING = Symbol.for("splashscreen:listingPatched");
+      const ORIG_ADD_CHILD = Symbol.for("splashscreen:origAddChild");
+      const ANIM_INTERVAL = Symbol.for("splashscreen:animInterval");
+      const DEBOUNCE_TIMER = Symbol.for("splashscreen:debounceTimer");
+
+      const origAddChildFn = vi.fn();
+      const patchedChild = {
+        [PATCHED_LISTING]: true,
+        [ORIG_ADD_CHILD]: origAddChildFn,
+        [ANIM_INTERVAL]: setInterval(() => {}, 10000),
+        [DEBOUNCE_TIMER]: setTimeout(() => {}, 10000),
+        addChild: vi.fn(),
+      };
+
+      const fakeTui = {
+        terminal: { rows: 24 },
+        children: [patchedChild],
+      } as unknown as TUI;
+
+      headerFactory(fakeTui, {} as Theme);
+
+      // Now trigger shutdown
+      triggerShutdown(ctx);
+
+      expect(patchedChild.addChild).toBe(origAddChildFn);
+      expect(patchedChild[PATCHED_LISTING]).toBe(false);
+      expect(patchedChild[ORIG_ADD_CHILD]).toBeUndefined();
+    });
+  });
+});

package/src/index.ts

@@ -0,0 +1,235 @@
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+  KeybindingsManager,
+  Theme,
+} from "@earendil-works/pi-coding-agent";
+import type {
+  TUI,
+  EditorTheme,
+  Component,
+} from "@earendil-works/pi-tui";
+
+import { HephaestusEditor } from "./editor/index.js";
+import { renderHeader, patchStartupListing, type ListingRef } from "./startup/index.js";
+import { patchConsoleLog, unpatchConsoleLog } from "./startup/capture.js";
+import { patchThinkingRenderer } from "./thinking/patch.js";
+import { transformThinkingContent } from "./thinking/transform.js";
+import {
+  loadUIConfig,
+  saveUIConfig,
+  DEFAULT_UI_CONFIG,
+  ANIMATION_STYLES,
+  normalizeThinkingStyle,
+  normalizeToolStyle,
+  type UIConfig,
+  type CoreConfig,
+} from "./config.js";
+import { getUISettingsItems } from "./settings.js";
+import { migrateCoreToUIConfig, migrateCompactThinkingToStyle, migrateRemovedToolPatch } from "./migration.js";
+import { registerBashToolOverride, clearActiveBashIntervals } from "./bash/index.js";
+import { registerCodemodeToolOverride, clearActiveCodemodeIntervals } from "./codemode/index.js";
+
+// Re-exports
+export { unpatchConsoleLog } from "./startup/capture.js";
+export { getUISettingsItems } from "./settings.js";
+export {
+  loadUIConfig,
+  saveUIConfig,
+  DEFAULT_UI_CONFIG,
+  ANIMATION_STYLES,
+  normalizeThinkingStyle,
+  normalizeToolStyle,
+  THINKING_STYLE_VALUES,
+  TOOL_STYLE_VALUES,
+  type UIConfig,
+  type CoreConfig,
+  type ThinkingStyle,
+  type ToolStyle,
+} from "./config.js";
+
+// Module-level state for session lifecycle
+let uiRef: ListingRef | undefined;
+let uiCtx: ExtensionContext | undefined;
+let uiTui: TUI | undefined;
+
+let spinFlag = false;
+let spinInterval: ReturnType<typeof setInterval> | undefined;
+
+function clearSpinInterval(): void {
+  if (spinInterval) {
+    clearInterval(spinInterval);
+    spinInterval = undefined;
+  }
+}
+
+export function registerUI(pi: ExtensionAPI): void {
+  // One-time migration of any legacy core config to UI config
+  migrateCoreToUIConfig();
+  migrateCompactThinkingToStyle();
+  // The toolStyle "Full" auto-expand patch was removed: drop any wrapper a
+  // previous version left on the shared prototype (upgrade + /reload case).
+  migrateRemovedToolPatch();
+
+  // Patch console.log for model scope capture
+  patchConsoleLog();
+
+  pi.on("message_end", (event, _ctx) => {
+    if (loadUIConfig().codeUnindent) {
+      transformThinkingContent(event.message as any);
+    }
+  });
+
+  // session_shutdown handler (top-level to prevent accumulation on /reload)
+  pi.on("session_shutdown", (_event, ctx) => {
+    unpatchConsoleLog();
+    clearActiveBashIntervals();
+    clearActiveCodemodeIntervals();
+
+    const targetCtx = ctx?.hasUI ? ctx : uiCtx;
+    if (targetCtx?.hasUI) {
+      targetCtx.ui.setWorkingVisible(true);
+      targetCtx.ui.setEditorComponent(undefined);
+    }
+    clearSpinInterval();
+    spinFlag = false;
+
+    if (uiRef) {
+      uiRef.settled = true;
+    }
+
+    const PATCHED_LISTING = Symbol.for("splashscreen:listingPatched");
+    const ORIG_ADD_CHILD = Symbol.for("splashscreen:origAddChild");
+    if (uiTui) {
+      try {
+        for (const child of uiTui.children) {
+          const cc = child as any;
+          if (cc[PATCHED_LISTING] && cc[ORIG_ADD_CHILD]) {
+            cc.addChild = cc[ORIG_ADD_CHILD];
+            cc[PATCHED_LISTING] = false;
+            cc[ORIG_ADD_CHILD] = undefined;
+          }
+        }
+        for (const topChild of uiTui.children) {
+          const tc = topChild as any;
+          if (!tc.children) continue;
+          for (const child of tc.children) {
+            const cc = child as any;
+            if (cc[PATCHED_LISTING] && cc[ORIG_ADD_CHILD]) {
+              cc.addChild = cc[ORIG_ADD_CHILD];
+              cc[PATCHED_LISTING] = false;
+              cc[ORIG_ADD_CHILD] = undefined;
+            }
+          }
+        }
+
+        const ANIM_INTERVAL = Symbol.for("splashscreen:animInterval");
+        const DEBOUNCE_TIMER = Symbol.for("splashscreen:debounceTimer");
+        for (const child of uiTui.children) {
+          const cc = child as any;
+          if (cc[ANIM_INTERVAL]) clearInterval(cc[ANIM_INTERVAL]);
+          if (cc[DEBOUNCE_TIMER]) clearTimeout(cc[DEBOUNCE_TIMER]);
+        }
+        for (const topChild of uiTui.children) {
+          const tc = topChild as any;
+          if (!tc.children) continue;
+          for (const child of tc.children) {
+            const cc = child as any;
+            if (cc[ANIM_INTERVAL]) clearInterval(cc[ANIM_INTERVAL]);
+            if (cc[DEBOUNCE_TIMER]) clearTimeout(cc[DEBOUNCE_TIMER]);
+          }
+        }
+      } catch {
+        /* TUI structure may have changed — ignore */
+      }
+    }
+  });
+
+  // session_start handler
+  pi.on("session_start", (_event, ctx: ExtensionContext) => {
+    uiCtx = ctx;
+
+    const config = loadUIConfig();
+    const toolStyle = normalizeToolStyle(config.toolStyle);
+
+    // Master gate: `Minimal` = archimedes tool styling (the per-tool
+    // toggles fine-tune it); `Native` = no archimedes tool styling at all
+    // — the overrides are not registered, so pi's native tool rendering
+    // stands (and no built-in-takeover startup notice).
+    if (toolStyle === "Minimal") {
+      if (config.bashToolStyling !== false) {
+        registerBashToolOverride(pi, ctx.cwd);
+      }
+
+      // The codemode override replaces pi's built-in codemode extension
+      // (the same take-over the bash override does for the core bash
+      // tool). It loads the native definition from the running CLI and
+      // swaps in the Archimedes renderers; it is a no-op on pi versions
+      // without the codemode extension.
+      if (config.codemodeToolStyling !== false) {
+        void registerCodemodeToolOverride(pi);
+      }
+    }
+
+    if (ctx.hasUI) {
+      spinFlag = config.editorSpinBorder;
+
+      // Set animated header
+      uiRef = {
+        sections: [],
+        frame: 0,
+        revealed: false,
+        revealedAt: 0,
+        scaffoldAt: 0,
+        settled: false,
+      };
+      const ref = uiRef;
+      const headerFactory = (tui: TUI, theme: Theme): Component & { dispose?(): void } => {
+        uiTui = tui;
+        const comp: Component & { dispose?(): void } = {
+          invalidate(): void {},
+          render(width: number): string[] {
+            return renderHeader(theme, ref, width, tui.terminal.rows - 3);
+          },
+        };
+        patchStartupListing(tui, theme, ref);
+        return comp;
+      };
+      ctx.ui.setHeader(headerFactory);
+
+      clearSpinInterval();
+      ctx.ui.setWorkingVisible(!spinFlag);
+
+      if (spinFlag) {
+        ctx.ui.setEditorComponent(
+          (tui: TUI, editorTheme: EditorTheme, keybindings: KeybindingsManager) => {
+            const theme = ctx.ui.theme;
+            return new HephaestusEditor(tui, editorTheme, keybindings, {
+              getTheme: () => theme,
+              isIdle: () => ctx.isIdle(),
+              shutdown: () => ctx.shutdown(),
+              spin: true,
+              spinSpeed: config.editorSpinSpeed,
+              spinStyle: config.editorSpinStyle,
+              spinLabel: config.editorSpinLabel,
+              onSpinInterval: (i) => {
+                spinInterval = i;
+              },
+            });
+          },
+        );
+      }
+
+      patchThinkingRenderer(() => ctx.ui.theme, {
+        labelText: config.labelText,
+        labelColor: config.labelColor,
+        autoCollapseThinking: config.autoCollapseThinking,
+        thinkingStyle: normalizeThinkingStyle(config.thinkingStyle),
+      });
+    }
+  });
+}
+
+export default function (pi: ExtensionAPI): void {
+  registerUI(pi);
+}