pi-advisor-flow 0.1.9 → 0.2.1

package/src/ui.ts

@@ -1,35 +1,60 @@
-import { Input, Key, matchesKey, fuzzyFilter, truncateToWidth, type Component, type Focusable } from "@earendil-works/pi-tui";
-import { Box, Text } from "@earendil-works/pi-tui";
 import type { Theme } from "@earendil-works/pi-coding-agent";
+import {
+  type Component,
+  type Focusable,
+  fuzzyFilter,
+  Input,
+  Key,
+  type Keybindings,
+  type KeybindingsManager,
+  matchesKey,
+  truncateToWidth,
+} from "@earendil-works/pi-tui";
+
+interface RenderRequester {
+  requestRender: () => void;
+}
+interface SearchableModelSelectorOptions {
+  allOptions: string[];
+  keybindings: KeybindingsManager;
+  onCancel: () => void;
+  onSelect: (value: string) => void;
+  theme: Theme;
+  title: string;
+  tui: RenderRequester;
+}
+interface AdvisorSettingsSelectorOptions {
+  effortLevels: string[];
+  initial: AdvisorSettings;
+  onCancel: () => void;
+  onSave: (settings: AdvisorSettings) => void;
+  presets: ContextPreset[];
+  theme: Theme;
+  tui: RenderRequester;
+}
 
 export class SearchableModelSelector implements Component, Focusable {
-  private tui: any;
-  private searchInput: Input;
-  private allOptions: string[];
+  private readonly tui: RenderRequester;
+  private readonly searchInput: Input;
+  private readonly allOptions: string[];
   private filteredOptions: string[];
   private selectedIndex = 0;
-  private title: string;
-  private onSelect: (value: string) => void;
-  private onCancel: () => void;
-  private theme: Theme;
-  private keybindings: any;
+  private readonly title: string;
+  private readonly onSelect: (value: string) => void;
+  private readonly onCancel: () => void;
+  private readonly theme: Theme;
+  private readonly keybindings: KeybindingsManager;
   private _focused = false;
 
-  public get focused(): boolean { return this._focused; }
-  public set focused(val: boolean) {
+  get focused(): boolean {
+    return this._focused;
+  }
+  set focused(val: boolean) {
     this._focused = val;
     this.searchInput.focused = val;
   }
 
-  constructor(options: {
-    tui: any;
-    title: string;
-    allOptions: string[];
-    theme: Theme;
-    keybindings: any;
-    onSelect: (value: string) => void;
-    onCancel: () => void;
-  }) {
+  constructor(options: SearchableModelSelectorOptions) {
     this.tui = options.tui;
     this.title = options.title;
     this.allOptions = options.allOptions;
@@ -41,103 +66,177 @@ export class SearchableModelSelector implements Component, Focusable {
     this.filteredOptions = this.allOptions;
   }
 
-  invalidate(): void { this.searchInput.invalidate(); }
+  invalidate(): void {
+    this.searchInput.invalidate();
+  }
 
   render(width: number): string[] {
     const lines: string[] = ["═".repeat(width)];
     lines.push(`  ${this.theme.fg("accent", this.theme.bold(this.title))}`);
     const inputLines = this.searchInput.render(width - 12);
-    lines.push(`  ${this.theme.fg("accent", "Search: ")}${inputLines[0] || ""}`);
+    lines.push(
+      `  ${this.theme.fg("accent", "Search: ")}${inputLines[0] || ""}`
+    );
     lines.push("");
 
     const query = this.searchInput.getValue().trim();
-    this.filteredOptions = query ? fuzzyFilter(this.allOptions, query, (item) => item) : this.allOptions;
-    this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, this.filteredOptions.length - 1));
+    this.filteredOptions = query
+      ? fuzzyFilter(this.allOptions, query, (item) => item)
+      : this.allOptions;
+    this.selectedIndex = Math.min(
+      this.selectedIndex,
+      Math.max(0, this.filteredOptions.length - 1)
+    );
 
     const maxVisible = 10;
     const total = this.filteredOptions.length;
     if (total === 0) {
-      lines.push("  " + this.theme.fg("muted", "No matching models found."));
+      lines.push(`  ${this.theme.fg("muted", "No matching models found.")}`);
     } else {
-      const startIndex = Math.max(0, Math.min(this.selectedIndex - Math.floor(maxVisible / 2), total - maxVisible));
+      const startIndex = Math.max(
+        0,
+        Math.min(
+          this.selectedIndex - Math.floor(maxVisible / 2),
+          total - maxVisible
+        )
+      );
       const endIndex = Math.min(startIndex + maxVisible, total);
-      for (let i = startIndex; i < endIndex; i++) {
+      for (let i = startIndex; i < endIndex; i += 1) {
         const item = this.filteredOptions[i];
-        if (i === this.selectedIndex) lines.push(`  ${this.theme.fg("accent", "→ ")}${this.theme.fg("accent", item)}`);
-        else lines.push(`    ${this.theme.fg("text", item)}`);
+        if (i === this.selectedIndex) {
+          lines.push(
+            `  ${this.theme.fg("accent", "→ ")}${this.theme.fg("accent", item)}`
+          );
+        } else {
+          lines.push(`    ${this.theme.fg("text", item)}`);
+        }
+      }
+      if (total > maxVisible) {
+        lines.push(
+          "  " +
+            this.theme.fg("muted", `  (${this.selectedIndex + 1}/${total})`)
+        );
       }
-      if (total > maxVisible) lines.push("  " + this.theme.fg("muted", `  (${this.selectedIndex + 1}/${total})`));
     }
     lines.push("");
-    lines.push(`  ${this.theme.fg("muted", "Type to search · ↑↓: navigate · Enter: select · Esc: cancel")}`);
+    lines.push(
+      `  ${this.theme.fg("muted", "Type to search · ↑↓: navigate · Enter: select · Esc: cancel")}`
+    );
     lines.push("═".repeat(width));
     return lines;
   }
 
   handleInput(keyData: string): void {
-    const kb = this.keybindings;
-    if (kb.matches(keyData, "tui.select.up") || keyData === "\u001b[A") {
-      if (this.filteredOptions.length > 0) this.selectedIndex = this.selectedIndex === 0 ? this.filteredOptions.length - 1 : this.selectedIndex - 1;
-      this.tui.requestRender();
-    } else if (kb.matches(keyData, "tui.select.down") || keyData === "\u001b[B") {
-      if (this.filteredOptions.length > 0) this.selectedIndex = this.selectedIndex === this.filteredOptions.length - 1 ? 0 : this.selectedIndex + 1;
-      this.tui.requestRender();
-    } else if (kb.matches(keyData, "tui.select.confirm") || keyData === "\n" || keyData === "\r") {
-      if (this.filteredOptions.length > 0) this.onSelect(this.filteredOptions[this.selectedIndex]);
-    } else if (kb.matches(keyData, "tui.select.cancel") || keyData === "\u001b") {
+    if (this.matchesAction(keyData, "tui.select.up", "\u001b[A")) {
+      this.moveSelection(-1);
+      return;
+    }
+    if (this.matchesAction(keyData, "tui.select.down", "\u001b[B")) {
+      this.moveSelection(1);
+      return;
+    }
+    if (
+      this.matchesAction(keyData, "tui.select.confirm", "\n") ||
+      keyData === "\r"
+    ) {
+      if (this.filteredOptions.length > 0) {
+        this.onSelect(this.filteredOptions[this.selectedIndex]);
+      }
+      return;
+    }
+    if (this.matchesAction(keyData, "tui.select.cancel", "\u001b")) {
       this.onCancel();
-    } else {
-      this.searchInput.handleInput(keyData);
-      this.selectedIndex = 0;
-      this.tui.requestRender();
+      return;
+    }
+    this.searchInput.handleInput(keyData);
+    this.selectedIndex = 0;
+    this.tui.requestRender();
+  }
+
+  private matchesAction(
+    keyData: string,
+    action: keyof Keybindings,
+    fallback: string
+  ) {
+    return this.keybindings.matches(keyData, action) || keyData === fallback;
+  }
+
+  private moveSelection(direction: -1 | 1) {
+    if (this.filteredOptions.length > 0) {
+      const lastIndex = this.filteredOptions.length - 1;
+      const nextIndex = this.selectedIndex + direction;
+      if (nextIndex < 0) {
+        this.selectedIndex = lastIndex;
+      } else if (nextIndex > lastIndex) {
+        this.selectedIndex = 0;
+      } else {
+        this.selectedIndex = nextIndex;
+      }
     }
+    this.tui.requestRender();
   }
 }
 
-export type ContextPreset = { label: string; value: number; description: string };
+export interface ContextPreset {
+  description: string;
+  label: string;
+  value: number;
+}
 
-export type AdvisorSettings = {
+export interface AdvisorSettings {
+  autoLoopGate?: boolean;
+  blockOnBlocked?: boolean;
+  collapseResponses: boolean;
+  completionGate: boolean;
   contextMaxChars: number;
+  customRule?: string;
   effort?: string;
-  planGate: boolean;
   failureGate: boolean;
-  completionGate: boolean;
-  collapseResponses: boolean;
-  customRule?: string;
-  blockOnBlocked?: boolean;
-  autoLoopGate?: boolean;
+  failureMode?: "block-session" | "block-tool" | "warn-and-continue";
+  herdrIntegration?: boolean;
   loopThreshold?: number;
   maxCallsPerSession?: number;
+  planGate: boolean;
   sessionSummary?: boolean;
-};
+  toolResultMaxBytes?: number;
+  toolResultMaxLines?: number;
+}
 
 export class AdvisorSettingsSelector implements Component, Focusable {
-  private selectedRow = 0;
+  private selectedRow: number;
   private contextIndex: number;
   private effortIndex: number;
-  private settings: AdvisorSettings;
-  private customInput = new Input();
-  private editingCustom = false;
+  private readonly settings: AdvisorSettings;
+  private readonly customInput = new Input();
+  private editingCustom: boolean;
   private _focused = false;
+  private readonly options: AdvisorSettingsSelectorOptions;
 
-  public get focused() { return this._focused; }
-  public set focused(value: boolean) {
+  get focused(): boolean {
+    return this._focused;
+  }
+  set focused(value: boolean) {
     this._focused = value;
     this.customInput.focused = value && this.editingCustom;
   }
 
-  constructor(private options: {
-    tui: any;
-    theme: Theme;
-    presets: ContextPreset[];
-    effortLevels: string[];
-    initial: AdvisorSettings;
-    onSave: (settings: AdvisorSettings) => void;
-    onCancel: () => void;
-  }) {
+  constructor(options: AdvisorSettingsSelectorOptions) {
+    this.selectedRow = 0;
+    this.editingCustom = false;
+    this.options = options;
     this.settings = { ...options.initial };
-    this.contextIndex = Math.max(0, options.presets.findIndex((preset) => preset.value === this.settings.contextMaxChars));
-    this.effortIndex = Math.max(0, options.effortLevels.indexOf(this.settings.effort || "Default (Model Default)"));
+    this.contextIndex = Math.max(
+      0,
+      options.presets.findIndex(
+        (preset) => preset.value === this.settings.contextMaxChars
+      )
+    );
+    this.effortIndex = Math.max(
+      0,
+      options.effortLevels.indexOf(
+        this.settings.effort || "Default (Model Default)"
+      )
+    );
     this.customInput.onSubmit = (value) => {
       this.settings.customRule = value.trim() || undefined;
       this.editingCustom = false;
@@ -151,46 +250,124 @@ export class AdvisorSettingsSelector implements Component, Focusable {
     };
   }
 
-  invalidate(): void { this.options.tui.requestRender(); }
+  invalidate(): void {
+    this.options.tui.requestRender();
+  }
 
-  private currentContext() { return this.options.presets[this.contextIndex]; }
+  private currentContext(): ContextPreset {
+    const preset = this.options.presets.find(
+      (item) => item.value === this.settings.contextMaxChars
+    );
+    return (
+      preset ?? {
+        description: "Current custom context limit",
+        label: String(this.settings.contextMaxChars),
+        value: this.settings.contextMaxChars,
+      }
+    );
+  }
+  private currentEffort() {
+    return this.settings.effort || "Default (Model Default)";
+  }
   private row(label: string, value: string, index: number) {
     const { theme } = this.options;
     const prefix = index === this.selectedRow ? theme.fg("accent", "›") : " ";
     const text = `${prefix} ${label.padEnd(28)} ${value}`;
-    return index === this.selectedRow ? theme.fg("accent", theme.bold(text)) : theme.fg("text", text);
+    return index === this.selectedRow
+      ? theme.fg("accent", theme.bold(text))
+      : theme.fg("text", text);
   }
 
   render(width: number): string[] {
     const { theme, presets } = this.options;
     const trackWidth = Math.max(24, Math.min(60, width - 4));
-    const positions = presets.map((_, index) => Math.round(index * (trackWidth - 1) / (presets.length - 1)));
+    const positions = presets.map((_, index) =>
+      Math.round((index * (trackWidth - 1)) / Math.max(1, presets.length - 1))
+    );
     const track = Array.from({ length: trackWidth }, () => "─");
     track[positions[this.contextIndex]] = "▲";
     const labels = Array.from({ length: trackWidth }, () => " ");
-    for (let index = 0; index < presets.length; index++) {
-      const label = presets[index].label;
-      const start = Math.max(0, Math.min(trackWidth - label.length, positions[index] - Math.floor(label.length / 2)));
-      for (let char = 0; char < label.length; char++) labels[start + char] = label[char];
+    for (let index = 0; index < presets.length; index += 1) {
+      const { label } = presets[index];
+      const start = Math.max(
+        0,
+        Math.min(
+          trackWidth - label.length,
+          positions[index] - Math.floor(label.length / 2)
+        )
+      );
+      for (let char = 0; char < label.length; char += 1) {
+        labels[start + char] = label[char];
+      }
     }
     const heading = `Recent history${" ".repeat(Math.max(1, trackWidth - "Recent history".length - "Full branch".length))}Full branch`;
-    const onOff = (value: boolean) => value ? "On" : "Off";
+    const onOff = (value: boolean) => (value ? "On" : "Off");
     const rows = [
       this.row("Context window", this.currentContext().label, 0),
-      this.row("Advisor reasoning", this.options.effortLevels[this.effortIndex], 1),
+      this.row("Advisor reasoning", this.currentEffort(), 1),
       this.row("Plan gate", onOff(this.settings.planGate), 2),
       this.row("Failure gate", onOff(this.settings.failureGate), 3),
       this.row("Completion gate", onOff(this.settings.completionGate), 4),
-      this.row("Collapse long responses", onOff(this.settings.collapseResponses), 5),
+      this.row(
+        "Collapse long responses",
+        onOff(this.settings.collapseResponses),
+        5
+      ),
       this.row("Custom invocation", this.settings.customRule || "None", 6),
-      this.row("Block on critical advice", onOff(this.settings.blockOnBlocked ?? true), 7),
-      this.row("Automatic loop gate", onOff(this.settings.autoLoopGate ?? true), 8),
-      this.row("Loop threshold", `After ${this.settings.loopThreshold ?? 3} repeats`, 9),
-      this.row("Max Advisor calls/session", this.settings.maxCallsPerSession === undefined ? "∞" : String(this.settings.maxCallsPerSession), 10),
-      this.row("Session Advisor Summary", onOff(this.settings.sessionSummary ?? true), 11),
+      this.row(
+        "Block on critical advice",
+        onOff(this.settings.blockOnBlocked ?? true),
+        7
+      ),
+      this.row(
+        "Automatic loop gate",
+        onOff(this.settings.autoLoopGate ?? true),
+        8
+      ),
+      this.row(
+        "Loop threshold",
+        `After ${this.settings.loopThreshold ?? 3} repeats`,
+        9
+      ),
+      this.row(
+        "Max Advisor calls/session",
+        this.settings.maxCallsPerSession === undefined
+          ? "∞"
+          : String(this.settings.maxCallsPerSession),
+        10
+      ),
+      this.row(
+        "Session Advisor Summary",
+        onOff(this.settings.sessionSummary ?? true),
+        11
+      ),
+      this.row(
+        "Gate failure mode",
+        this.settings.failureMode ?? "block-session",
+        12
+      ),
+      this.row(
+        "Herdr integration",
+        onOff(this.settings.herdrIntegration ?? true),
+        13
+      ),
+      this.row(
+        "Tool result lines",
+        String(this.settings.toolResultMaxLines ?? 2000),
+        14
+      ),
+      this.row(
+        "Tool result bytes",
+        String(this.settings.toolResultMaxBytes ?? 50 * 1024),
+        15
+      ),
     ];
-    if (this.editingCustom) rows.push(`    ${this.customInput.render(Math.max(10, width - 6))[0] || ""}`);
-    rows.push(this.row("Save changes", "", 12));
+    if (this.editingCustom) {
+      rows.push(
+        `    ${this.customInput.render(Math.max(10, width - 6))[0] || ""}`
+      );
+    }
+    rows.push(this.row("Save changes", "", 16));
     return [
       theme.fg("accent", theme.bold("  Advisor settings")),
       "",
@@ -213,7 +390,7 @@ export class AdvisorSettingsSelector implements Component, Focusable {
     if (matchesKey(keyData, Key.up)) {
       this.selectedRow = Math.max(0, this.selectedRow - 1);
     } else if (matchesKey(keyData, Key.down)) {
-      this.selectedRow = Math.min(12, this.selectedRow + 1);
+      this.selectedRow = Math.min(16, this.selectedRow + 1);
     } else if (matchesKey(keyData, Key.left)) {
       this.adjust(-1);
     } else if (matchesKey(keyData, Key.right)) {
@@ -226,32 +403,125 @@ export class AdvisorSettingsSelector implements Component, Focusable {
         tui.requestRender();
         return;
       }
-      if (this.selectedRow === 12) return this.options.onSave({ ...this.settings, contextMaxChars: this.currentContext().value, effort: this.options.effortLevels[this.effortIndex] });
+      if (this.selectedRow === 16) {
+        this.options.onSave({
+          ...this.settings,
+          contextMaxChars: this.currentContext().value,
+          effort: this.currentEffort(),
+        });
+        return;
+      }
       this.adjust(1);
     } else if (matchesKey(keyData, Key.escape)) {
-      return this.options.onCancel();
-    } else return;
+      this.options.onCancel();
+      return;
+    } else {
+      return;
+    }
     tui.requestRender();
   }
 
   private adjust(direction: number) {
     switch (this.selectedRow) {
-      case 0: this.contextIndex = Math.max(0, Math.min(this.options.presets.length - 1, this.contextIndex + direction)); break;
-      case 1: this.effortIndex = Math.max(0, Math.min(this.options.effortLevels.length - 1, this.effortIndex + direction)); break;
-      case 2: this.settings.planGate = !this.settings.planGate; break;
-      case 3: this.settings.failureGate = !this.settings.failureGate; break;
-      case 4: this.settings.completionGate = !this.settings.completionGate; break;
-      case 5: this.settings.collapseResponses = !this.settings.collapseResponses; break;
-      case 7: this.settings.blockOnBlocked = !(this.settings.blockOnBlocked ?? true); break;
-      case 8: this.settings.autoLoopGate = !(this.settings.autoLoopGate ?? true); break;
-      case 9: this.settings.loopThreshold = Math.max(2, (this.settings.loopThreshold ?? 3) + direction); break;
+      case 0:
+        this.contextIndex = Math.max(
+          0,
+          Math.min(
+            this.options.presets.length - 1,
+            this.contextIndex + direction
+          )
+        );
+        this.settings.contextMaxChars =
+          this.options.presets[this.contextIndex].value;
+        break;
+      case 1:
+        this.effortIndex = Math.max(
+          0,
+          Math.min(
+            this.options.effortLevels.length - 1,
+            this.effortIndex + direction
+          )
+        );
+        this.settings.effort = this.options.effortLevels[this.effortIndex];
+        break;
+      case 2:
+        this.settings.planGate = !this.settings.planGate;
+        break;
+      case 3:
+        this.settings.failureGate = !this.settings.failureGate;
+        break;
+      case 4:
+        this.settings.completionGate = !this.settings.completionGate;
+        break;
+      case 5:
+        this.settings.collapseResponses = !this.settings.collapseResponses;
+        break;
+      case 7:
+        this.settings.blockOnBlocked = !(this.settings.blockOnBlocked ?? true);
+        break;
+      case 8:
+        this.settings.autoLoopGate = !(this.settings.autoLoopGate ?? true);
+        break;
+      case 9:
+        this.settings.loopThreshold = Math.max(
+          2,
+          (this.settings.loopThreshold ?? 3) + direction
+        );
+        break;
       case 10: {
         const values = [undefined, 0, 1, 2, 3, 5, 10, 25, 50];
-        const index = Math.max(0, values.indexOf(this.settings.maxCallsPerSession));
-        this.settings.maxCallsPerSession = values[Math.max(0, Math.min(values.length - 1, index + direction))];
+        const index = Math.max(
+          0,
+          values.indexOf(this.settings.maxCallsPerSession)
+        );
+        this.settings.maxCallsPerSession =
+          values[Math.max(0, Math.min(values.length - 1, index + direction))];
         break;
       }
-      case 11: this.settings.sessionSummary = !(this.settings.sessionSummary ?? true); break;
+      case 11:
+        this.settings.sessionSummary = !(this.settings.sessionSummary ?? true);
+        break;
+      case 12: {
+        const modes: AdvisorSettings["failureMode"][] = [
+          "block-session",
+          "block-tool",
+          "warn-and-continue",
+        ];
+        const index = Math.max(
+          0,
+          modes.indexOf(this.settings.failureMode ?? "block-session")
+        );
+        this.settings.failureMode =
+          modes[Math.max(0, Math.min(modes.length - 1, index + direction))];
+        break;
+      }
+      case 13:
+        this.settings.herdrIntegration = !(
+          this.settings.herdrIntegration ?? true
+        );
+        break;
+      case 14: {
+        const values = [0, 500, 1000, 2000, 5000, 10_000];
+        const index = Math.max(
+          0,
+          values.indexOf(this.settings.toolResultMaxLines ?? 2000)
+        );
+        this.settings.toolResultMaxLines =
+          values[Math.max(0, Math.min(values.length - 1, index + direction))];
+        break;
+      }
+      case 15: {
+        const values = [0, 10 * 1024, 50 * 1024, 100 * 1024, 500 * 1024];
+        const index = Math.max(
+          0,
+          values.indexOf(this.settings.toolResultMaxBytes ?? 50 * 1024)
+        );
+        this.settings.toolResultMaxBytes =
+          values[Math.max(0, Math.min(values.length - 1, index + direction))];
+        break;
+      }
+      default:
+        break;
     }
   }
 }