pi-llama-cpp 0.12.0 → 0.14.0

package/src/ui/editors/listEditor.ts

@@ -0,0 +1,291 @@
+import { getSettingsListTheme } from "@earendil-works/pi-coding-agent";
+import type { Component } from "@earendil-works/pi-tui";
+import { SettingsList } from "@earendil-works/pi-tui";
+import type { LlamaServer } from "../../interfaces/settings";
+import { BaseDialog } from "../dialog/base";
+import { DialogFactory } from "../dialog/factory";
+import { HINTS } from "../strings";
+import type { SettingsListEditorOptions } from "./editorOptions";
+
+// ─── Abstract base class ──────────────────────────────────────────────────
+
+/**
+ * Base class for SettingsList-based editors that manage a list of servers
+ * with add/delete support at the top level.
+ *
+ * Subclasses must implement:
+ * - {@link buildSettingsList} — how to build the top-level list items
+ * - {@link beginAdd} — how to start the add wizard
+ * - {@link deleteSelected} — how to delete the selected entry
+ * - {@link getRowLabel} — display name for a row at the given index
+ * - {@link emptyHintKey} — which hint to show when the list is empty
+ * - {@link deleteTitle} — dialog title for the delete confirmation
+ */
+export abstract class ListEditor<
+  O extends SettingsListEditorOptions = SettingsListEditorOptions,
+> implements Component {
+  protected settingsList: SettingsList | null = null;
+  protected isFocused = false;
+  /** The currently open modal dialog (add wizard, input, or confirm),
+   * when one is up: input/render/invalidate/focus all delegate to it
+   * until it is cleared via {@link closeDialog}. */
+  protected activeDialog: BaseDialog | undefined;
+  /** Dialog factory holding `theme`/`tui` once for all dialog construction. */
+  protected readonly dialogs: DialogFactory;
+  /** Whether a row's field submenu is open. While open, input is delegated
+   * to the settingsList and list rebuilds are deferred: rebuilding would
+   * discard the submenu and kick the user back to the list. */
+  protected submenuOpen = false;
+  /** Row index of a rebuild deferred by {@link commitFieldChange} while a
+   * submenu was open; flushed by {@link trackSubmenu} on close. */
+  private deferredRebuild: number | null = null;
+  /** Selected row index. Mirrors the `SettingsList`'s selection, which is
+   * `private` in pi-tui's typings and thus unreachable — so this copy is
+   * advanced by the same wrap-around logic the list applies internally
+   * (both handle the same up/down keypress). Kept in sync explicitly in
+   * {@link rebuildList} via `selectItem`. */
+  protected selectedIndex = 0;
+
+  constructor(protected readonly options: O) {
+    this.dialogs = new DialogFactory(options.theme, options.tui);
+  }
+
+  // -- abstract hooks -------------------------------------------------------
+
+  /** Build the top-level SettingsList from the current data snapshot. */
+  protected abstract buildSettingsList(): SettingsList | Promise<SettingsList>;
+
+  /** Start the add wizard (called when user presses "a"). */
+  protected abstract beginAdd(): void;
+
+  /** Delete the currently selected entry (called after confirmation). */
+  protected abstract deleteSelected(): void;
+
+  /** Hint line key for the empty-list state. */
+  protected abstract readonly emptyHintKey:
+    | "emptyServers"
+    | "emptyOverrideEntries";
+
+  /** Total item count (entries or servers) for selection clamping. */
+  protected abstract getCurrentCount(): number;
+
+  /** Returns the id for a row at the given index. */
+  protected abstract getRowId(index: number): string;
+
+  /** Returns the display label for a row at the given index. */
+  protected abstract getRowLabel(index: number): string;
+
+  /** Title for the delete confirmation dialog (e.g. "Delete server"). */
+  protected abstract get deleteTitle(): string;
+
+  // -- hooks -----------------------------------------------------------------
+
+  /**
+   * Closes this editor on Esc. The base implementation ends the whole
+   * dialog (`options.done`) — correct for top-level editors. Drill-down
+   * subclasses that live inside another editor's submenu override this
+   * to step back one level instead (their `options.done` still points
+   * at the top-level close inherited through the shared options).
+   */
+  protected close(): void {
+    this.options.done();
+  }
+
+  // -- Focusable ------------------------------------------------------------
+
+  get focused(): boolean {
+    return this.isFocused;
+  }
+
+  set focused(value: boolean) {
+    this.isFocused = value;
+    if (this.activeDialog) this.activeDialog.focused = value;
+  }
+
+  // -- Component ------------------------------------------------------------
+
+  invalidate(): void {
+    this.settingsList?.invalidate();
+    this.activeDialog?.invalidate();
+  }
+
+  handleInput(data: string): void {
+    // Delegate to the open modal dialog, if any
+    if (this.activeDialog) {
+      this.activeDialog.handleInput(data);
+      return;
+    }
+
+    // Delegate to settingsList if a submenu is open
+    if (this.submenuOpen && this.settingsList) {
+      this.settingsList.handleInput(data);
+      return;
+    }
+
+    // Top-level keybindings. Up/down mirror the wrap-around the
+    // `SettingsList` applies internally to the same keypress (its
+    // selection is private — see the {@link selectedIndex} doc); the
+    // trailing forward to `settingsList.handleInput` is what actually
+    // moves the rendered cursor.
+    const kb = this.options.keybindings;
+    if (kb.matches(data, "tui.select.cancel")) {
+      this.close();
+      return;
+    }
+    if (kb.matches(data, "tui.select.up")) {
+      this.selectedIndex =
+        this.selectedIndex === 0
+          ? this.getCurrentCount() - 1
+          : this.selectedIndex - 1;
+    }
+    if (kb.matches(data, "tui.select.down")) {
+      this.selectedIndex =
+        this.selectedIndex === this.getCurrentCount() - 1
+          ? 0
+          : this.selectedIndex + 1;
+    }
+    if (data === "a") {
+      this.beginAdd();
+      return;
+    }
+    if (data === "d") {
+      this.beginConfirm();
+      return;
+    }
+    if (this.settingsList) {
+      this.settingsList.handleInput(data);
+    }
+  }
+
+  render(width: number): string[] {
+    // Delegate to the open modal dialog, if any
+    if (this.activeDialog) return this.activeDialog.render(width);
+
+    // Empty list hint
+    if (!this.settingsList) return ["Loading..."];
+    const lines = this.settingsList.render(width);
+    if (this.getCurrentCount() === 0) {
+      lines[lines.length - 1] = getSettingsListTheme().hint(
+        HINTS[this.emptyHintKey],
+      );
+    }
+    return lines;
+  }
+
+  // -- helpers ---------------------------------------------------------------
+
+  /**
+   * Rebuilds the list and places the cursor on `targetIndex`.
+   * Subclasses call this after add/delete/persist to refresh the UI.
+   */
+  protected async rebuildList(targetIndex: number): Promise<void> {
+    const list = await this.buildSettingsList();
+    this.settingsList = list;
+    const count = this.getCurrentCount();
+    if (count === 0) {
+      this.selectedIndex = 0;
+      return;
+    }
+    this.selectedIndex = Math.min(targetIndex, count - 1);
+    this.settingsList.selectItem(this.getRowId(this.selectedIndex));
+    // Rebuilding is async (health checks); request a render only once the
+    // new list is in place, otherwise the old frame stays on screen
+    this.options.tui.requestRender();
+  }
+
+  /**
+   * Tracks a row's field submenu opening or closing. While a submenu is
+   * open, {@link rebuildList} would discard it and kick the user back to
+   * the list — so a rebuild deferred by {@link commitFieldChange} is
+   * flushed here on close instead of running mid-edit.
+   */
+  protected trackSubmenu(open: boolean): void {
+    this.submenuOpen = open;
+    if (open) return;
+    const index = this.deferredRebuild;
+    this.deferredRebuild = null;
+    if (index !== null) void this.rebuildList(index);
+  }
+
+  /**
+   * Opens a modal dialog: input/render delegate to it until
+   * {@link closeDialog}. Focus follows the editor's.
+   */
+  protected openDialog(dialog: BaseDialog): void {
+    this.activeDialog = dialog;
+    dialog.focused = this.isFocused;
+    this.options.tui.requestRender();
+  }
+
+  /** Closes the open modal dialog and returns to the list. */
+  protected closeDialog(): void {
+    this.activeDialog = undefined;
+    this.options.tui.requestRender();
+  }
+
+  /**
+   * Opens the delete confirmation dialog.
+   */
+  protected beginConfirm(): void {
+    const idx = this.selectedIndex;
+    const name = this.getRowLabel(idx);
+    if (!name) return;
+
+    this.openDialog(
+      this.dialogs.confirmDelete(
+        this.deleteTitle,
+        name,
+        () => {
+          this.closeDialog();
+          void this.deleteSelected();
+        },
+        () => this.closeDialog(),
+      ),
+    );
+  }
+
+  /**
+   * Persists `next`; on success adopts it and runs `onSuccess`;
+   * on failure notifies and stays in list mode.
+   *
+   * Callers must close any open dialog *before* the async persist:
+   * render() returns the list once `activeDialog` is cleared, so
+   * leaving the dialog open would blank the screen mid-save.
+   */
+  protected async persistSnapshot(
+    next: LlamaServer[],
+    onSuccess: () => void,
+  ): Promise<void> {
+    try {
+      await this.options.persist(next);
+    } catch (err) {
+      this.options.onError(String(err));
+      this.options.tui.requestRender();
+      return;
+    }
+    this.options.servers = next;
+    onSuccess();
+  }
+
+  /**
+   * Handles a field commit from an open row submenu: persists `next` and,
+   * on success, refreshes the open submenu UI in place via `refresh`, then
+   * defers the full list rebuild of row `deferIndex` until the submenu
+   * closes (rebuilding now would discard the submenu and kick the user
+   * back to the list — see {@link trackSubmenu}). No-op when
+   * `next` is the current list (unchanged, callers compare by reference).
+   */
+  protected commitFieldChange(
+    next: LlamaServer[],
+    deferIndex: number | null,
+    refresh: () => void,
+  ): void {
+    if (next === this.options.servers) return;
+    void this.persistSnapshot(next, () => {
+      refresh();
+      if (deferIndex !== null && this.submenuOpen)
+        this.deferredRebuild = deferIndex;
+      this.options.tui.requestRender();
+    });
+  }
+}

package/src/ui/editors/override/entry.ts

@@ -0,0 +1,24 @@
+import type { LlamaServer, ModelOverride } from "../../../interfaces/settings";
+
+/**
+ * One override entry: the pattern key and its override object. Owns the
+ * canonical construction from a server's overrides map, so the editor
+ * and the mutator share a single entry representation. Row rendering
+ * (summary) is registry-driven — see `OverrideSummary`.
+ */
+export class OverrideEntry {
+  constructor(
+    readonly pattern: string,
+    readonly override: ModelOverride,
+  ) {}
+
+  /**
+   * Entries of a server's overrides map, in map iteration order (the
+   * order the entry list renders and mutates by).
+   */
+  static listFrom(server: LlamaServer | undefined): OverrideEntry[] {
+    return Object.entries(server?.overrides ?? {}).map(
+      ([pattern, override]) => new OverrideEntry(pattern, override),
+    );
+  }
+}

package/src/ui/editors/override/entryEditor.ts

@@ -0,0 +1,166 @@
+import type { SettingItem, SettingsList } from "@earendil-works/pi-tui";
+import { FIELDS, FieldMessages, HINTS, TITLES } from "../../strings";
+import type { OverrideSettingsListOptions } from "../editorOptions";
+import { ListEditor } from "../listEditor";
+import { SettingsListFactory } from "../settingsListFactory";
+import { OverrideEntry } from "./entry";
+import { OverrideFields, OverrideSummary } from "./fields";
+import { OverrideEntryMutator } from "./handlers";
+import { OverrideItemBuilder } from "./itemBuilder";
+
+/**
+ * The override entries of a single server, as a list view with add/delete.
+ */
+export class OverrideEntryListEditor extends ListEditor<OverrideSettingsListOptions> {
+  /** Currently open field submenu, so commits can refresh its rows */
+  private fieldList: SettingsList | null = null;
+
+  constructor(
+    /** Shared options object — `persistSnapshot` updates `options.servers`
+     * in place so later drill-downs (and sibling editors) see the change */
+    options: OverrideSettingsListOptions,
+    private readonly serverIndex: number,
+    /** Closes this editor (called on Esc in the entry list) */
+    private readonly done: () => void,
+  ) {
+    super(options);
+    this.settingsList = this.buildSettingsList();
+  }
+
+  // -- hooks ---------------------------------------------------------------
+
+  /** Esc steps back to the server list, not out of the whole dialog —
+   * `options.done` is the top-level close (shared options object). */
+  protected close(): void {
+    this.done();
+  }
+
+  // -- abstract hooks -------------------------------------------------------
+
+  protected buildSettingsList(): SettingsList {
+    const builder = new OverrideItemBuilder(this.dialogs);
+    const items: SettingItem[] = this.mutator.entries().map((entry, i) => ({
+      id: `entry-${i}`,
+      label: entry.pattern,
+      description: HINTS.overrideEntryRow,
+      currentValue: OverrideSummary.of(entry.override),
+      submenu: (_cv, done) => {
+        const current = this.mutator.entries()[i] ?? entry;
+        const fieldItems = builder.buildFieldItems(current);
+        const fieldList = SettingsListFactory.create(
+          fieldItems,
+          () => {
+            this.fieldList = null;
+            done();
+            // Flushes any rebuild deferred by a pattern rename
+            // (see commitFieldChange)
+            this.trackSubmenu(false);
+          },
+          (field, value) => void this.handleFieldChange(i, field, value),
+        );
+        this.fieldList = fieldList;
+        this.trackSubmenu(true);
+        return fieldList;
+      },
+    }));
+
+    return SettingsListFactory.create(items, () => {
+      this.done();
+    });
+  }
+
+  /** Handle a field commit from a row's submenu. */
+  private handleFieldChange(
+    entryIndex: number,
+    field: string,
+    value: string,
+  ): void {
+    const result = this.mutator.applyFieldChange(entryIndex, field, value);
+    if (!result) return;
+
+    this.commitFieldChange(
+      result.next,
+      // The entry row's label is the pattern, and SettingsList labels
+      // can't be patched in place — defer the rebuild until the submenu
+      // closes so the user stays inside it (see commitFieldChange)
+      field === "pattern" ? entryIndex : null,
+      () => {
+        // Refresh the entry row's summary in place
+        this.settingsList?.updateValue(
+          `entry-${entryIndex}`,
+          OverrideSummary.of(result.updatedOverride),
+        );
+        // Refresh the committed row in the open field submenu. Passing
+        // `value` as the pattern makes the pattern field display the new
+        // pattern; other fields only read the override.
+        this.fieldList?.updateValue(
+          field,
+          OverrideFields.byId(field).displayValue(
+            new OverrideEntry(value, result.updatedOverride),
+          ),
+        );
+      },
+    );
+  }
+
+  protected beginAdd(): void {
+    this.openDialog(
+      this.dialogs.input({
+        title: TITLES.addOverride,
+        message: FieldMessages.of(FIELDS.pattern),
+        placeholder: FIELDS.pattern.placeholder,
+        validate: OverrideFields.byId("pattern").validate,
+        onSubmit: (value) => {
+          this.closeDialog();
+          void this.saveAdd(value);
+        },
+        onCancel: () => this.closeDialog(),
+      }),
+    );
+  }
+
+  protected deleteSelected(): void {
+    const idx = this.selectedIndex;
+    const next = this.mutator.removeEntry(idx);
+    void this.persistSnapshot(next, () => {
+      this.rebuildList(idx);
+      this.options.onChanged?.();
+      this.options.tui.requestRender();
+    });
+  }
+
+  protected readonly emptyHintKey = "emptyOverrideEntries" as const;
+
+  protected getCurrentCount(): number {
+    return this.mutator.entries().length;
+  }
+
+  protected getRowId(index: number): string {
+    return `entry-${index}`;
+  }
+
+  protected getRowLabel(index: number): string {
+    return this.mutator.entries()[index]?.pattern ?? "";
+  }
+
+  protected get deleteTitle(): string {
+    return TITLES.deleteOverride;
+  }
+
+  // -- helpers ---------------------------------------------------------------
+
+  /** Fresh mutator over the current servers snapshot — `persistSnapshot`
+   * replaces `options.servers` in place, so instances can't be cached. */
+  private get mutator(): OverrideEntryMutator {
+    return new OverrideEntryMutator(this.options.servers, this.serverIndex);
+  }
+
+  private async saveAdd(pattern: string): Promise<void> {
+    const next = this.mutator.addEntry(pattern);
+    await this.persistSnapshot(next, () => {
+      this.rebuildList(this.mutator.entries().length - 1);
+      this.options.onChanged?.();
+      this.options.tui.requestRender();
+    });
+  }
+}