@pi-unipi/utility 0.2.3 → 0.2.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/utility",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Utility commands and tools for Pi coding agent — lifecycle, diagnostics, cache, analytics, display, batch execution",
   "type": "module",
   "license": "MIT",

package/src/commands.ts

@@ -22,6 +22,7 @@ import { runDiagnostics, formatDiagnosticsReport } from "./diagnostics/engine.js
 import { getEnvironmentInfo, formatEnvironmentInfo } from "./tools/env.js";
 import type { NameBadgeState } from "./tui/name-badge-state.js";
 import { readBadgeSettings, updateBadgeSetting, formatBadgeSettings } from "./tui/badge-settings.js";
+import { BadgeSettingsTui } from "./tui/badge-settings-tui.js";
 
 /** Send a markdown response via pi.sendMessage */
 function sendResponse(pi: ExtensionAPI, markdown: string): void {
@@ -36,14 +37,14 @@ function sendResponse(pi: ExtensionAPI, markdown: string): void {
 }
 
 /**
- * Register name badge commands: /unipi:name-badge, /unipi:badge-gen.
+ * Register name badge commands: /unipi:badge-name, /unipi:badge-gen.
  */
 export function registerNameBadgeCommands(
   pi: ExtensionAPI,
   state: NameBadgeState,
 ): void {
-  // ─── /unipi:name-badge — toggle badge overlay ───────────────────────────
-  pi.registerCommand(`${UNIPI_PREFIX}${UTILITY_COMMANDS.NAME_BADGE}`, {
+  // ─── /unipi:badge-name — toggle badge overlay ───────────────────────────
+  pi.registerCommand(`${UNIPI_PREFIX}${UTILITY_COMMANDS.BADGE_NAME}`, {
     description: "Toggle session name badge overlay",
     handler: async (_args: string, ctx: ExtensionContext) => {
       if (!ctx.hasUI) {
@@ -95,6 +96,42 @@ export function registerNameBadgeCommands(
       sendResponse(pi, formatBadgeSettings(settings));
     },
   });
+
+  // ─── /unipi:badge-settings — TUI settings overlay ──────────────────────
+  pi.registerCommand(`${UNIPI_PREFIX}${UTILITY_COMMANDS.BADGE_SETTINGS}`, {
+    description: "Configure badge settings via TUI overlay",
+    handler: async (_args: string, ctx: ExtensionContext) => {
+      if (!ctx.hasUI) {
+        ctx.ui.notify("Badge settings require an interactive UI.", "warning");
+        return;
+      }
+
+      ctx.ui.custom(
+        (tui: any, _theme: any, _keybindings: any, done: any) => {
+          const overlay = new BadgeSettingsTui();
+          overlay.onClose = () => done(undefined);
+          overlay.requestRender = () => tui.requestRender();
+          return {
+            render: (w: number) => overlay.render(w),
+            invalidate: () => overlay.invalidate(),
+            handleInput: (data: string) => {
+              overlay.handleInput(data);
+              tui.requestRender();
+            },
+          };
+        },
+        {
+          overlay: true,
+          overlayOptions: {
+            width: "80%",
+            minWidth: 50,
+            anchor: "center",
+            margin: 2,
+          },
+        },
+      );
+    },
+  });
 }
 
 /**

package/src/index.ts

@@ -29,6 +29,9 @@ import { getLifecycle } from "./lifecycle/process.js";
 import { getAnalyticsCollector } from "./analytics/collector.js";
 import { registerInfoScreen } from "./info-screen.js";
 
+/** Re-export readBadgeSettings for cross-package use */
+export { readBadgeSettings } from "./tui/badge-settings.js";
+
 /** Package version */
 const VERSION = getPackageVersion(new URL(".", import.meta.url).pathname);
 
@@ -43,9 +46,10 @@ const ALL_COMMANDS = [
   UTILITY_COMMANDS.CLEANUP,
   UTILITY_COMMANDS.ENV,
   UTILITY_COMMANDS.DOCTOR,
-  UTILITY_COMMANDS.NAME_BADGE,
+  UTILITY_COMMANDS.BADGE_NAME,
   UTILITY_COMMANDS.BADGE_GEN,
   UTILITY_COMMANDS.BADGE_TOGGLE,
+  UTILITY_COMMANDS.BADGE_SETTINGS,
 ].map((cmd) => `unipi:${cmd}`);
 
 /** All tools registered by this module */
@@ -66,6 +70,8 @@ export default function (pi: ExtensionAPI) {
   // Initialize name badge state
   const nameBadgeState = new NameBadgeState();
 
+  // Capture session context for cross-event use (not needed if BADGE_GENERATE_REQUEST removed)
+
   // Register commands
   registerUtilityCommands(pi);
   registerNameBadgeCommands(pi, nameBadgeState);
@@ -89,6 +95,15 @@ export default function (pi: ExtensionAPI) {
 
     // Restore name badge if it was visible in previous session
     await nameBadgeState.restore(pi, ctx);
+
+    // Write model cache for TUI components
+    if ((ctx as any).modelRegistry) {
+      const { writeModelCache } = await import("@pi-unipi/core");
+      const registry = (ctx as any).modelRegistry;
+      const models = (registry.getAvailable?.() ?? registry.getAll())
+        .map((m: any) => ({ provider: m.provider, id: m.id, name: m.name }));
+      writeModelCache(models);
+    }
   });
 
   // First-message hook: auto-generate session name on first user message
@@ -127,14 +142,6 @@ export default function (pi: ExtensionAPI) {
     }
   });
 
-  // Listen for badge generation requests from other modules (e.g., kanboard)
-  pi.on(UNIPI_EVENTS.BADGE_GENERATE_REQUEST as any, async (_event: any, ctx: any) => {
-    // Show badge overlay if not already visible
-    if (!nameBadgeState.isVisible() && ctx?.hasUI) {
-      await nameBadgeState.show(pi, ctx);
-    }
-  });
-
   // Track command usage
   pi.on("tool_call", async (event) => {
     if (event.toolName.startsWith("unipi:")) {

package/src/tui/badge-settings-tui.ts

@@ -0,0 +1,388 @@
+/**
+ * @pi-unipi/utility — Badge Settings TUI Overlay
+ *
+ * Interactive settings overlay for badge configuration.
+ * Three settings: auto-generate toggle, badge-enabled toggle, generation model selector.
+ * Model list loaded from shared model cache (~/.unipi/config/models-cache.json).
+ */
+
+import type { Component } from "@mariozechner/pi-tui";
+import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import type { CachedModel } from "@pi-unipi/core";
+import { readModelCache } from "@pi-unipi/core";
+import {
+  readBadgeSettings,
+  writeBadgeSettings,
+  type BadgeSettings,
+} from "./badge-settings.js";
+
+/** ANSI escape codes */
+const ansi = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  cyan: "\x1b[36m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  gray: "\x1b[90m",
+  white: "\x1b[37m",
+};
+
+/** Toggle symbols */
+const TOGGLE_ON = `${ansi.green}●${ansi.reset}`;
+const TOGGLE_OFF = `${ansi.dim}○${ansi.reset}`;
+
+/** Active mode */
+type Mode = "settings" | "model-picker";
+
+/** Setting row types */
+interface BooleanSetting {
+  type: "boolean";
+  key: keyof BadgeSettings;
+  label: string;
+  description: string;
+  getValue: (s: BadgeSettings) => boolean;
+}
+
+interface ModelSetting {
+  type: "model";
+  key: "generationModel";
+  label: string;
+  description: string;
+}
+
+type SettingItem = BooleanSetting | ModelSetting;
+
+/** Settings list */
+const SETTINGS: SettingItem[] = [
+  {
+    type: "boolean",
+    key: "autoGen",
+    label: "Auto generate",
+    description: "Generate session name on first user message",
+    getValue: (s) => s.autoGen,
+  },
+  {
+    type: "boolean",
+    key: "badgeEnabled",
+    label: "Badge enabled",
+    description: "Show the name badge overlay",
+    getValue: (s) => s.badgeEnabled,
+  },
+  {
+    type: "model",
+    key: "generationModel",
+    label: "Generation model",
+    description: "Model to use for badge name generation",
+  },
+];
+
+/**
+ * Badge Settings TUI overlay.
+ * Implements the Component interface for use with ctx.ui.custom().
+ */
+export class BadgeSettingsTui implements Component {
+  private settings: BadgeSettings;
+  private mode: Mode = "settings";
+  private selectedIndex = 0;
+  private modelScrollOffset = 0;
+  private models: CachedModel[] = [];
+
+  /** Theme reference for rendering (set externally) */
+  private _theme: any = null;
+
+  /** Callback when overlay should close */
+  onClose?: () => void;
+
+  /** Callback to request a re-render */
+  requestRender?: () => void;
+
+  constructor() {
+    this.settings = readBadgeSettings();
+    this.models = readModelCache();
+  }
+
+  /**
+   * Set the pi-tui theme for styled rendering.
+   */
+  setTheme(theme: any): void {
+    this._theme = theme;
+  }
+
+  /**
+   * Invalidate cached render state.
+   */
+  invalidate(): void {
+    // No cached state to invalidate
+  }
+
+  /**
+   * Handle keyboard input.
+   */
+  handleInput(data: string): void {
+    if (this.mode === "settings") {
+      this.handleSettingsInput(data);
+    } else {
+      this.handleModelPickerInput(data);
+    }
+  }
+
+  /**
+   * Handle input in settings mode.
+   */
+  private handleSettingsInput(data: string): void {
+    switch (data) {
+      case "\x1b[A": // Up arrow
+      case "k":
+        this.selectedIndex =
+          (this.selectedIndex - 1 + SETTINGS.length) % SETTINGS.length;
+        break;
+      case "\x1b[B": // Down arrow
+      case "j":
+        this.selectedIndex = (this.selectedIndex + 1) % SETTINGS.length;
+        break;
+      case " ": // Space — toggle boolean settings
+        this.toggleCurrentSetting();
+        break;
+      case "\r": // Enter — open model picker or toggle
+        if (SETTINGS[this.selectedIndex].type === "model") {
+          this.enterModelPicker();
+        } else {
+          this.toggleCurrentSetting();
+        }
+        break;
+      case "\x1b": // Escape — close and save
+        this.save();
+        this.onClose?.();
+        break;
+    }
+  }
+
+  /**
+   * Handle input in model picker mode.
+   */
+  private handleModelPickerInput(data: string): void {
+    const allModels = this.getModelList();
+
+    switch (data) {
+      case "\x1b[A": // Up arrow
+      case "k":
+        this.selectedIndex =
+          (this.selectedIndex - 1 + allModels.length) % allModels.length;
+        this.adjustModelScroll(allModels.length);
+        break;
+      case "\x1b[B": // Down arrow
+      case "j":
+        this.selectedIndex = (this.selectedIndex + 1) % allModels.length;
+        this.adjustModelScroll(allModels.length);
+        break;
+      case "\r": // Enter — select model
+        this.selectModel();
+        break;
+      case "\x1b": // Escape — cancel picker
+        this.mode = "settings";
+        this.selectedIndex = SETTINGS.findIndex(
+          (s) => s.key === "generationModel",
+        );
+        break;
+    }
+  }
+
+  /**
+   * Toggle the currently selected boolean setting.
+   */
+  private toggleCurrentSetting(): void {
+    const item = SETTINGS[this.selectedIndex];
+    if (item.type !== "boolean") return;
+
+    const current = item.getValue(this.settings);
+    (this.settings as any)[item.key] = !current;
+    this.save();
+  }
+
+  /**
+   * Enter model picker mode.
+   */
+  private enterModelPicker(): void {
+    this.mode = "model-picker";
+    const allModels = this.getModelList();
+    const currentModel = this.settings.generationModel;
+    this.selectedIndex = allModels.findIndex((m) => m.id === currentModel);
+    if (this.selectedIndex < 0) this.selectedIndex = 0;
+    this.modelScrollOffset = 0;
+    this.adjustModelScroll(allModels.length);
+  }
+
+  /**
+   * Select the current model in the picker.
+   */
+  private selectModel(): void {
+    const allModels = this.getModelList();
+    const selected = allModels[this.selectedIndex];
+    if (selected) {
+      this.settings.generationModel = selected.id;
+      this.save();
+    }
+    this.mode = "settings";
+    this.selectedIndex = SETTINGS.findIndex((s) => s.key === "generationModel");
+  }
+
+  /**
+   * Get model list with "inherit" as first entry.
+   */
+  private getModelList(): Array<{ id: string; label: string }> {
+    const list: Array<{ id: string; label: string }> = [
+      { id: "inherit", label: "inherit (use parent model)" },
+    ];
+    for (const m of this.models) {
+      const fullId = `${m.provider}/${m.id}`;
+      list.push({
+        id: fullId,
+        label: m.name ? `${fullId} (${m.name})` : fullId,
+      });
+    }
+    return list;
+  }
+
+  /**
+   * Adjust scroll offset so the selected item is visible.
+   */
+  private adjustModelScroll(totalItems: number): void {
+    // Reserve ~10 lines for visible model list
+    const visibleLines = 10;
+    if (this.selectedIndex < this.modelScrollOffset) {
+      this.modelScrollOffset = this.selectedIndex;
+    } else if (this.selectedIndex >= this.modelScrollOffset + visibleLines) {
+      this.modelScrollOffset = this.selectedIndex - visibleLines + 1;
+    }
+    // Clamp
+    this.modelScrollOffset = Math.max(
+      0,
+      Math.min(this.modelScrollOffset, totalItems - visibleLines),
+    );
+  }
+
+  /**
+   * Save settings to disk.
+   */
+  private save(): void {
+    writeBadgeSettings(this.settings);
+  }
+
+  /**
+   * Render the overlay.
+   */
+  render(width: number): string[] {
+    const lines: string[] = [];
+    const innerWidth = Math.max(44, width - 2);
+
+    const padVisible = (content: string, targetWidth: number): string => {
+      const vw = visibleWidth(content);
+      const pad = Math.max(0, targetWidth - vw);
+      return content + " ".repeat(pad);
+    };
+
+    const add = (s: string) =>
+      lines.push(
+        `${ansi.cyan}│${ansi.reset}` +
+          padVisible(truncateToWidth(s, innerWidth), innerWidth) +
+          `${ansi.cyan}│${ansi.reset}`,
+      );
+
+    const addEmpty = () =>
+      lines.push(
+        `${ansi.cyan}│${ansi.reset}` +
+          " ".repeat(innerWidth) +
+          `${ansi.cyan}│${ansi.reset}`,
+      );
+
+    // Top border
+    lines.push(`${ansi.cyan}╭${"─".repeat(innerWidth)}╮${ansi.reset}`);
+
+    // Header
+    add(`${ansi.bold}${ansi.cyan}Badge Settings${ansi.reset}`);
+    add(`${ansi.dim}Configure badge generation behavior${ansi.reset}`);
+    addEmpty();
+
+    // Settings list
+    for (let i = 0; i < SETTINGS.length; i++) {
+      const item = SETTINGS[i];
+      const isSelected = i === this.selectedIndex && this.mode === "settings";
+      const selector = isSelected ? `${ansi.cyan}▸${ansi.reset}` : " ";
+
+      if (item.type === "boolean") {
+        const value = item.getValue(this.settings);
+        const toggle = value ? TOGGLE_ON : TOGGLE_OFF;
+        const labelColor = isSelected ? ansi.bold : ansi.dim;
+
+        add(
+          `${selector} ${toggle} ${labelColor}${item.label}${ansi.reset}`,
+        );
+        add(`   ${ansi.gray}${item.description}${ansi.reset}`);
+      } else if (item.type === "model") {
+        const labelColor = isSelected ? ansi.bold : ansi.dim;
+        const modelDisplay = this.settings.generationModel;
+
+        add(
+          `${selector} ${ansi.yellow}⚙${ansi.reset} ${labelColor}${item.label}${ansi.reset}: ${ansi.white}${modelDisplay}${ansi.reset}`,
+        );
+        add(`   ${ansi.gray}${item.description}${ansi.reset}`);
+        add(`   ${ansi.dim}Enter to select model${ansi.reset}`);
+      }
+    }
+
+    // Model picker (inline)
+    if (this.mode === "model-picker") {
+      addEmpty();
+      add(`${ansi.bold}${ansi.cyan}── Available Models ──${ansi.reset}`);
+
+      const allModels = this.getModelList();
+      const visibleLines = 10;
+      const start = this.modelScrollOffset;
+      const end = Math.min(start + visibleLines, allModels.length);
+
+      // Scroll indicator up
+      if (start > 0) {
+        add(`  ${ansi.dim}▲ ${start} more above${ansi.reset}`);
+      }
+
+      for (let i = start; i < end; i++) {
+        const m = allModels[i];
+        const isSelected = i === this.selectedIndex;
+        const selector = isSelected ? `${ansi.cyan}▸${ansi.reset}` : " ";
+        const labelColor = isSelected ? ansi.bold + ansi.white : ansi.dim;
+
+        add(
+          `${selector} ${labelColor}${m.label}${ansi.reset}`,
+        );
+      }
+
+      // Scroll indicator down
+      if (end < allModels.length) {
+        add(
+          `  ${ansi.dim}▼ ${allModels.length - end} more below${ansi.reset}`,
+        );
+      }
+    }
+
+    // Footer
+    addEmpty();
+
+    if (this.mode === "model-picker") {
+      add(
+        `${ansi.dim}↑↓ navigate • Enter select • Esc cancel${ansi.reset}`,
+      );
+    } else {
+      add(
+        `${ansi.dim}↑↓ navigate • Space toggle • Enter select model • Esc close${ansi.reset}`,
+      );
+      add(`${ansi.dim}Config: .unipi/config/badge.json${ansi.reset}`);
+    }
+
+    // Bottom border
+    lines.push(`${ansi.cyan}╰${"─".repeat(innerWidth)}╯${ansi.reset}`);
+
+    return lines;
+  }
+}

package/src/tui/badge-settings.ts

@@ -16,6 +16,8 @@ export interface BadgeSettings {
   badgeEnabled: boolean;
   /** Enable the set_session_name tool for agents */
   agentTool: boolean;
+  /** Model to use for badge name generation. "inherit" = parent model, or "provider/model-id" */
+  generationModel: string;
 }
 
 /** Default badge settings */
@@ -23,6 +25,7 @@ const DEFAULT_SETTINGS: BadgeSettings = {
   autoGen: true,
   badgeEnabled: true,
   agentTool: true,
+  generationModel: "inherit",
 };
 
 /** Badge settings file name */
@@ -48,6 +51,7 @@ export function readBadgeSettings(): BadgeSettings {
       autoGen: typeof parsed.autoGen === "boolean" ? parsed.autoGen : DEFAULT_SETTINGS.autoGen,
       badgeEnabled: typeof parsed.badgeEnabled === "boolean" ? parsed.badgeEnabled : DEFAULT_SETTINGS.badgeEnabled,
       agentTool: typeof parsed.agentTool === "boolean" ? parsed.agentTool : DEFAULT_SETTINGS.agentTool,
+      generationModel: typeof parsed.generationModel === "string" ? parsed.generationModel : DEFAULT_SETTINGS.generationModel,
     };
   } catch {
     return { ...DEFAULT_SETTINGS };
@@ -97,6 +101,7 @@ export function formatBadgeSettings(settings: BadgeSettings): string {
     `| Auto Generate | ${toggle(settings.autoGen)} | Generate name on first message |`,
     `| Badge Enabled | ${toggle(settings.badgeEnabled)} | Show badge overlay |`,
     `| Agent Tool | ${toggle(settings.agentTool)} | Allow agents to call set_session_name |`,
+    `| Generation Model | ${settings.generationModel} | Model for badge name generation |`,
     "",
     `Config: \`${BADGE_CONFIG_FILE}\``,
   ].join("\n");