pi-advisor-flow 0.5.0 → 0.5.2

package/src/ui/settings-selector.ts

@@ -0,0 +1,161 @@
+import { getSettingsListTheme } from "@earendil-works/pi-coding-agent";
+import {
+  type Component,
+  type Focusable,
+  SettingsList,
+  truncateToWidth,
+} from "@earendil-works/pi-tui";
+import {
+  rainbowGradient,
+  SIMPLE_MODE_GRADIENT_INTERVAL_MS,
+} from "./settings-formatting.js";
+import { createSettingsItems } from "./settings-items.js";
+import { SettingsListAdapter } from "./settings-list-adapter.js";
+import { mutateAdvisorSettings } from "./settings-mutations.js";
+import type {
+  AdvisorSettings,
+  AdvisorSettingsSelectorOptions,
+  ContextPreset,
+} from "./types.js";
+
+export class AdvisorSettingsSelector implements Component, Focusable {
+  private readonly options: AdvisorSettingsSelectorOptions;
+  private readonly settings: AdvisorSettings;
+  private readonly presets: ContextPreset[];
+  private settingsList: SettingsListAdapter;
+  private simpleModeGradientStartedAt: number | undefined;
+  private simpleModeGradientTimer: ReturnType<typeof setInterval> | undefined;
+  private _focused = false;
+
+  get focused(): boolean {
+    return this._focused;
+  }
+
+  set focused(value: boolean) {
+    this._focused = value;
+    this.settingsList.setFocused(value);
+  }
+
+  constructor(options: AdvisorSettingsSelectorOptions) {
+    this.options = options;
+    this.settings = { ...options.initial };
+    const configuredContext = this.settings.contextMaxChars;
+    this.presets = options.presets.some(
+      (preset) => preset.value === configuredContext
+    )
+      ? [...options.presets]
+      : [
+          ...options.presets,
+          {
+            description: "Current custom context limit",
+            label: String(configuredContext),
+            value: configuredContext,
+          },
+        ].sort((a, b) => a.value - b.value);
+    if (this.settings.simpleMode) {
+      this.startSimpleModeGradient();
+    }
+    this.settingsList = this.createSettingsList();
+  }
+
+  invalidate(): void {
+    this.settingsList.invalidate();
+  }
+
+  dispose(): void {
+    this.stopSimpleModeGradient();
+  }
+
+  render(width: number): string[] {
+    const border = this.options.theme.fg(
+      "border",
+      "─".repeat(Math.max(1, width))
+    );
+    return [border, ...this.settingsList.render(width), border].map((line) =>
+      truncateToWidth(line, width)
+    );
+  }
+
+  handleInput(keyData: string): void {
+    if (
+      !this.settingsList.changeWithArrow(keyData, (id, value) =>
+        this.change(id, value)
+      )
+    ) {
+      this.settingsList.handleInput(keyData);
+    }
+    this.options.tui.requestRender();
+  }
+
+  private createSettingsList(selectedId?: string): SettingsListAdapter {
+    const listTheme = getSettingsListTheme();
+    const defaultLabel = listTheme.label;
+    listTheme.label = (text, selected) => {
+      if (this.settings.simpleMode && text.startsWith("Simple mode")) {
+        return `${rainbowGradient("Simple mode", this.simpleModeGradientStartedAt ?? 0)}${text.slice("Simple mode".length)}`;
+      }
+      return defaultLabel(text, selected);
+    };
+    const items = createSettingsItems({
+      effortLevels: this.options.effortLevels,
+      presets: this.presets,
+      settings: this.settings,
+      theme: this.options.theme,
+      tui: this.options.tui,
+    });
+    const list = new SettingsList(
+      items,
+      10,
+      listTheme,
+      (id, value) => this.change(id, value),
+      this.options.onCancel,
+      { enableSearch: true }
+    );
+    const adapter = new SettingsListAdapter(list);
+    if (selectedId) {
+      adapter.setSelectedId(items, selectedId);
+    }
+    return adapter;
+  }
+
+  private startSimpleModeGradient(): void {
+    this.stopSimpleModeGradient();
+    this.simpleModeGradientStartedAt = Date.now();
+    this.simpleModeGradientTimer = setInterval(() => {
+      this.options.tui.requestRender();
+    }, SIMPLE_MODE_GRADIENT_INTERVAL_MS);
+    this.simpleModeGradientTimer.unref?.();
+  }
+
+  private stopSimpleModeGradient(): void {
+    if (this.simpleModeGradientTimer) {
+      clearInterval(this.simpleModeGradientTimer);
+      this.simpleModeGradientTimer = undefined;
+    }
+    this.simpleModeGradientStartedAt = undefined;
+  }
+
+  private change(id: string, value: string): void {
+    mutateAdvisorSettings(this.settings, id, value, this.presets);
+    if (id === "simpleMode") {
+      if (this.settings.simpleMode) {
+        this.startSimpleModeGradient();
+      } else {
+        this.stopSimpleModeGradient();
+      }
+    }
+    (this.options.onChange ?? this.options.onSave)?.({
+      ...this.settings,
+      showUsageDetails: this.settings.showUsageDetails ?? true,
+      toolPolicies: { ...(this.settings.toolPolicies ?? {}) },
+    });
+    if (
+      id === "context" ||
+      id === "simpleMode" ||
+      id === "customRule" ||
+      id === "toolPolicies"
+    ) {
+      this.settingsList = this.createSettingsList(id);
+    }
+  }
+}

package/src/ui/text-setting-submenu.ts

@@ -0,0 +1,66 @@
+import {
+  type Component,
+  type Focusable,
+  Input,
+  truncateToWidth,
+} from "@earendil-works/pi-tui";
+import type { TextSettingSubmenuOptions } from "./types.js";
+
+/** Small inline editor used by SettingsList for the two free-form settings. */
+export class TextSettingSubmenu implements Component, Focusable {
+  private readonly input = new Input();
+  private readonly options: TextSettingSubmenuOptions;
+  private _focused = true;
+  private error: string | undefined;
+
+  get focused(): boolean {
+    return this._focused;
+  }
+
+  set focused(value: boolean) {
+    this._focused = value;
+    this.input.focused = value;
+  }
+
+  constructor(options: TextSettingSubmenuOptions) {
+    this.options = options;
+    this.input.setValue(options.initial);
+    this.input.focused = true;
+    this.input.onSubmit = (value) => {
+      const result = options.onSubmit(value);
+      if (result.error) {
+        this.error = result.error;
+        options.tui.requestRender();
+        return;
+      }
+      this.error = undefined;
+      options.onCancel(result.value);
+    };
+    this.input.onEscape = () => options.onCancel();
+  }
+
+  invalidate(): void {
+    this.input.invalidate();
+  }
+
+  render(width: number): string[] {
+    const { theme } = this.options;
+    const input = this.input.render(Math.max(10, width - 4))[0] || "";
+    const lines = [
+      theme.fg("accent", theme.bold(`  ${this.options.title}`)),
+      "",
+      theme.fg("muted", `  ${this.options.description}`),
+      "",
+      `  ${input}`,
+    ];
+    if (this.error) {
+      lines.push(theme.fg("error", `  ${this.error}`));
+    }
+    lines.push("", theme.fg("dim", "  Enter: apply · Esc: cancel"));
+    return lines.map((line) => truncateToWidth(line, width));
+  }
+
+  handleInput(keyData: string): void {
+    this.input.handleInput(keyData);
+  }
+}

package/src/ui/types.ts

@@ -0,0 +1,111 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { KeybindingsManager, TUI } from "@earendil-works/pi-tui";
+import type { GateFailureMode } from "../config/types.js";
+import type { GitContextLevel } from "../git.js";
+
+export interface RenderRequester {
+  requestRender: () => void;
+}
+
+export interface SearchableModelSelectorOptions {
+  allOptions: string[];
+  currentOption?: string;
+  keybindings: KeybindingsManager;
+  onCancel: () => void;
+  onSelect: (value: string) => void;
+  theme: Theme;
+  title: string;
+  tui: RenderRequester;
+}
+
+export interface ManualAdvisorRequest {
+  /** The repository disclosure level selected for this consultation. */
+  gitContext: GitContextLevel;
+  /** The unnormalized message entered in the dialog, when one was supplied. */
+  message?: string;
+}
+
+export interface ManualAdvisorDialogOptions {
+  gitContext: GitContextLevel;
+  initialMessage?: string;
+  keybindings: KeybindingsManager;
+  onCancel: () => void;
+  onSubmit: (request: ManualAdvisorRequest) => void;
+  theme: Theme;
+  tui: TUI;
+}
+
+export type ManualAdvisorFocus = "editor" | "git" | "actions";
+
+export interface ManualAdvisorDialogView {
+  actionIndex: number;
+  editorLines: string[];
+  focusTarget: ManualAdvisorFocus;
+  gitContext: GitContextLevel;
+  gitIndex: number;
+  gitLevels: GitContextLevel[];
+  horizontalPadding: number;
+  renderWidth: number;
+  theme: Theme;
+}
+
+export interface ContextPreset {
+  description: string;
+  label: string;
+  value: number;
+}
+
+export interface AdvisorSettings {
+  alwaysOn?: boolean;
+  autoLoopGate?: boolean;
+  blockOnBlocked?: boolean;
+  collapseResponses: boolean;
+  completionGate: boolean;
+  contextMaxChars: number;
+  customRule?: string;
+  effort?: string;
+  failureGate: boolean;
+  failureMode?: GateFailureMode;
+  gitContext?: GitContextLevel;
+  gitContextMaxChars?: number;
+  herdrIntegration?: boolean;
+  loopThreshold?: number;
+  maxCallsPerSession?: number;
+  outcomeLogging?: boolean;
+  planGate: boolean;
+  redactSecrets?: boolean;
+  scoutEnabled?: boolean;
+  sessionSummary?: boolean;
+  showUsageDetails?: boolean;
+  showUsageFooter?: boolean;
+  simpleMode?: boolean;
+  toolPolicies?: Record<string, "full" | "summary" | "exclude">;
+  toolResultMaxBytes?: number;
+  toolResultMaxLines?: number;
+  trackedFileContent?: boolean;
+  untrackedContent?: boolean;
+}
+
+export interface AdvisorSettingsSelectorOptions {
+  effortLevels: string[];
+  initial: AdvisorSettings;
+  onCancel: () => void;
+  onChange?: (settings: AdvisorSettings) => void;
+  /** @deprecated Use onChange; retained for extensions embedding this component. */
+  onSave?: (settings: AdvisorSettings) => void;
+  presets: ContextPreset[];
+  theme: Theme;
+  tui: RenderRequester;
+}
+
+export interface TextSettingSubmenuOptions {
+  description: string;
+  initial: string;
+  onCancel: (value?: string) => void;
+  onSubmit: (value: string) => { error?: string; value?: string };
+  theme: Theme;
+  title: string;
+  tui: RenderRequester;
+}
+
+export type SettingValue = string | undefined;