pi-llama-cpp 0.11.0 → 0.13.0

package/src/ui/serverSettingsList.ts

@@ -0,0 +1,513 @@
+import {
+  getSettingsListTheme,
+  type Theme,
+} from "@earendil-works/pi-coding-agent";
+import type {
+  Component,
+  Focusable,
+  KeybindingsManager,
+  TUI,
+} from "@earendil-works/pi-tui";
+import { SettingsList, type SettingItem } from "@earendil-works/pi-tui";
+import type { LlamaServer } from "../interfaces/settings";
+import { ConfirmDialog, InputDialog } from "./dialog";
+import {
+  formatServerSuffix,
+  getServerHealthEmoji,
+  normalizeServerUrl,
+} from "./serverListEditor";
+import { fieldMessage, FIELDS, HINTS, TITLES } from "./strings";
+
+/**
+ * Options for the SettingsList-based server editor.
+ */
+export interface ServerSettingsListOptions {
+  /** TUI instance, used to request re-renders after async persists */
+  tui: TUI;
+  /** Theme for dialogs (from the ctx.ui.custom factory) */
+  theme: Theme;
+  /** App keybindings manager (injected by ctx.ui.custom) */
+  keybindings: KeybindingsManager;
+  /**
+   * Snapshot of the merged `llamaSettings.servers` to edit. Replaced
+   * in place (`options.servers = next`) after every successful persist
+   * so the rebuilt rows reflect the adopted list.
+   */
+  servers: LlamaServer[];
+  /** Persists a new server list; a rejection keeps the current list */
+  persist: (next: LlamaServer[]) => Promise<void>;
+  /** Closes the editor (called on Esc in the server list) */
+  done: () => void;
+  /** Notifies about persistence errors */
+  onError: (message: string) => void;
+  /** Timeout (ms) for health checks. Defaults to 1000ms if not provided. */
+  serverTimeout?: number;
+}
+
+/**
+ * Builds the SettingItem for one server's editable fields (URL, id, name).
+ * Each field is infinite → opens an `InputDialog` submenu; commits are
+ * reported by the containing `SettingsList`'s `onChange` (field id → value).
+ */
+const buildServerFieldItems = (
+  server: LlamaServer,
+  theme: Theme,
+  tui: TUI,
+): SettingItem[] => [
+  {
+    id: "url",
+    label: FIELDS.serverUrl.label,
+    description: FIELDS.serverUrl.description,
+    currentValue: server.url,
+    submenu: InputDialog.inputSubmenu(
+      theme,
+      tui,
+      TITLES.edit(FIELDS.serverUrl.label),
+      fieldMessage(FIELDS.serverUrl),
+      FIELDS.serverUrl.placeholder,
+      normalizeServerUrl,
+    ),
+  },
+  {
+    id: "id",
+    label: FIELDS.providerId.label,
+    description: FIELDS.providerId.description,
+    currentValue: server.id ?? "",
+    submenu: InputDialog.inputSubmenu(
+      theme,
+      tui,
+      TITLES.edit(FIELDS.providerId.label),
+      fieldMessage(FIELDS.providerId),
+      FIELDS.providerId.placeholder,
+    ),
+  },
+  {
+    id: "name",
+    label: FIELDS.displayName.label,
+    description: FIELDS.displayName.description,
+    currentValue: server.name ?? "",
+    submenu: InputDialog.inputSubmenu(
+      theme,
+      tui,
+      TITLES.edit(FIELDS.displayName.label),
+      fieldMessage(FIELDS.displayName),
+      FIELDS.displayName.placeholder,
+    ),
+  },
+];
+
+/**
+ * Builds the SettingItem for one server row in the top-level list.
+ * Enter drills into the server's field-edit submenu.
+ */
+const buildServerRow = (
+  server: LlamaServer,
+  index: number,
+  theme: Theme,
+  tui: TUI,
+  onChange: (field: string, value: string) => void,
+  healthEmoji: string,
+  onSubmenuChange: (open: boolean) => void,
+): SettingItem => ({
+  id: `server-${index}`,
+  label: `${healthEmoji} ${server.url}`,
+  description: HINTS.serverRow,
+  currentValue: formatServerSuffix(server),
+  submenu: (_cv, done) => {
+    // Rebuild the field items on open so they prefill with current values
+    const items = buildServerFieldItems(server, theme, tui);
+    onSubmenuChange(true);
+    return new SettingsList(
+      items,
+      Math.min(items.length + 2, 15),
+      getSettingsListTheme(),
+      // Field commits arrive here: done(value) from the input submenus
+      (field, value) => onChange(field, value),
+      () => {
+        onSubmenuChange(false);
+        done();
+      },
+    );
+  },
+});
+
+/**
+ * Wrapper around a `SettingsList` of servers that adds `a` (add) and `d`
+ * (delete) support at the list level.
+ *
+ * - **a** opens the add wizard — a sequence of framed `InputDialog`s
+ *   (URL → optional ID → optional name, mirroring `/login`'s sequential
+ *   prompts). Esc at any step aborts without persisting; the server is
+ *   saved only after the final step.
+ * - **d** opens a `ConfirmDialog` (Delete/Cancel select list).
+ * - **Enter** on a server row drills into its field-edit submenu.
+ * - **Esc** closes the editor.
+ */
+export class ServerSettingsList implements Component, Focusable {
+  private settingsList!: SettingsList;
+  private mode: "list" | "wizard" | "confirm" = "list";
+  private wizardStep = 0;
+  private wizardUrl = "";
+  private wizardId = "";
+  private wizardDialog: InputDialog | undefined;
+  private confirmDialog: ConfirmDialog | undefined;
+  private isFocused = false;
+  /** True while a server row's field-edit submenu is open */
+  private submenuOpen = false;
+
+  constructor(private readonly options: ServerSettingsListOptions) {
+    this.buildSettingsList().then((list) => {
+      this.settingsList = list;
+      this.options.tui.requestRender();
+    });
+  }
+
+  /**
+   * Builds the top-level `SettingsList` from the current
+   * `options.servers`. Called on construction and rebuilt after every
+   * successful persist so added/deleted/edited servers are reflected
+   * immediately (the initial snapshot is not mutated by `persist`).
+   */
+  private async buildSettingsList(): Promise<SettingsList> {
+    const { theme, tui } = this.options;
+    const serverTimeout = this.options.serverTimeout ?? 1000;
+    // Check health for each server in parallel
+    const healthEmojis = await Promise.all(
+      this.options.servers.map((server) =>
+        getServerHealthEmoji(server.url, serverTimeout),
+      ),
+    );
+
+    // A fresh list never has a submenu open (also covers the rebuild
+    // paths, which discard any open field submenu)
+    this.submenuOpen = false;
+    const items: SettingItem[] = this.options.servers.map((server, i) =>
+      buildServerRow(
+        server,
+        i,
+        theme,
+        tui,
+        (field, value) => this.handleFieldChange(field, value),
+        healthEmojis[i],
+        (open) => {
+          this.submenuOpen = open;
+        },
+      ),
+    );
+
+    return new SettingsList(
+      items,
+      Math.min(items.length + 2, 15),
+      getSettingsListTheme(),
+      () => {
+        // Top-level onChange is a no-op (servers don't change at this level)
+      },
+      () => {
+        this.options.done();
+      },
+    );
+  }
+
+  // -- Focusable -----------------------------------------------------------
+
+  get focused(): boolean {
+    return this.isFocused;
+  }
+
+  set focused(value: boolean) {
+    this.isFocused = value;
+    if (this.wizardDialog) this.wizardDialog.focused = value;
+    if (this.confirmDialog) this.confirmDialog.focused = value;
+  }
+
+  // -- Component -----------------------------------------------------------
+
+  invalidate(): void {
+    this.settingsList?.invalidate();
+    this.wizardDialog?.invalidate();
+    this.confirmDialog?.invalidate();
+  }
+
+  handleInput(data: string): void {
+    if (this.mode === "wizard") {
+      this.wizardDialog?.handleInput(data);
+      return;
+    }
+
+    if (this.mode === "confirm") {
+      this.confirmDialog?.handleInput(data);
+      return;
+    }
+
+    // A server row's field submenu is open: delegate everything (Esc,
+    // a/d, arrows) to the containing SettingsList, which forwards input
+    // to the submenu. Intercepting here would close the whole editor on
+    // Esc and trigger add/delete while typing in a field.
+    if (this.submenuOpen) {
+      this.settingsList?.handleInput(data);
+      return;
+    }
+
+    const kb = this.options.keybindings;
+    if (kb.matches(data, "tui.select.cancel")) {
+      this.options.done();
+      return;
+    }
+    // Track selection for add/delete
+    if (kb.matches(data, "tui.select.up")) {
+      this._selectedIndex =
+        this._selectedIndex === 0
+          ? this.options.servers.length - 1
+          : this._selectedIndex - 1;
+    }
+    if (kb.matches(data, "tui.select.down")) {
+      this._selectedIndex =
+        this._selectedIndex === this.options.servers.length - 1
+          ? 0
+          : this._selectedIndex + 1;
+    }
+    if (data === "a") {
+      this.beginWizard();
+      return;
+    }
+    if (data === "d") {
+      this.beginConfirm();
+      return;
+    }
+    // Delegate to SettingsList (it handles up/down internally for rendering)
+    this.settingsList?.handleInput(data);
+  }
+
+  render(width: number): string[] {
+    if (this.mode === "wizard") {
+      return this.wizardDialog?.render(width) ?? [];
+    }
+
+    if (this.mode === "confirm") {
+      return this.confirmDialog?.render(width) ?? [];
+    }
+
+    // settingsList may not be initialized yet if buildSettingsList is still
+    // resolving health checks (async in constructor). Return empty until ready.
+    if (!this.settingsList) return [];
+
+    // List mode: the shortcuts live in the rows' description; only when the
+    // list is empty (no rows → no description) show them as the hint line
+    const settingsLines = this.settingsList.render(width);
+    if (this.options.servers.length === 0) {
+      settingsLines[settingsLines.length - 1] = getSettingsListTheme().hint(
+        HINTS.emptyServers,
+      );
+    }
+    return settingsLines;
+  }
+
+  // -- helpers ---------------------------------------------------------------
+
+  private selectedIndex(): number {
+    // Manual tracker for add/delete targeting, kept in sync with the
+    // SettingsList's cursor by rebuildList (SettingsList doesn't expose
+    // a getter)
+    return this._selectedIndex;
+  }
+
+  private _selectedIndex = 0;
+
+  /**
+   * Rebuilds the server list and places the cursor on `targetIndex`
+   * (clamped to the last row). A fresh SettingsList starts its cursor
+   * at index 0, so `selectItem` is used to restore the position.
+   */
+  private async rebuildList(targetIndex: number): Promise<void> {
+    const list = await this.buildSettingsList();
+    this.settingsList = list;
+    const count = this.options.servers.length;
+    if (count === 0) {
+      this._selectedIndex = 0;
+      return;
+    }
+    const target = Math.min(targetIndex, count - 1);
+    this._selectedIndex = target;
+    this.settingsList.selectItem(`server-${target}`);
+  }
+
+  // -- add wizard ---------------------------------------------------------------
+
+  /**
+   * Opens the add wizard at step 1/3 (URL). Esc at any step cancels the
+   * whole wizard; the server is persisted only after the final step.
+   */
+  private beginWizard(): void {
+    this.mode = "wizard";
+    this.wizardStep = 0;
+    this.wizardUrl = "";
+    this.wizardId = "";
+    this.showWizardStep();
+    this.options.tui.requestRender();
+  }
+
+  private showWizardStep(): void {
+    const { theme, tui } = this.options;
+    const step = this.wizardStep;
+
+    const dialog =
+      step === 0
+        ? new InputDialog({
+            theme,
+            tui,
+            title: TITLES.addServerStep(1),
+            message: fieldMessage(FIELDS.serverUrl),
+            placeholder: FIELDS.serverUrl.placeholder,
+            validate: normalizeServerUrl,
+            onSubmit: (value) => this.wizardSubmit(value),
+            onCancel: () => this.cancelWizard(),
+          })
+        : step === 1
+          ? new InputDialog({
+              theme,
+              tui,
+              title: TITLES.addServerStep(2),
+              message: fieldMessage(FIELDS.providerId, "(optional)"),
+              placeholder: FIELDS.providerId.placeholder,
+              onSubmit: (value) => this.wizardSubmit(value),
+              onCancel: () => this.cancelWizard(),
+            })
+          : new InputDialog({
+              theme,
+              tui,
+              title: TITLES.addServerStep(3),
+              message: fieldMessage(FIELDS.displayName, "(optional)"),
+              placeholder: FIELDS.displayName.placeholder,
+              onSubmit: (value) => this.wizardSubmit(value),
+              onCancel: () => this.cancelWizard(),
+            });
+
+    this.wizardDialog = dialog;
+    dialog.focused = this.isFocused;
+  }
+
+  private wizardSubmit(value: string): void {
+    if (this.wizardStep === 0) {
+      this.wizardUrl = value;
+      this.wizardStep = 1;
+      this.showWizardStep();
+    } else if (this.wizardStep === 1) {
+      this.wizardId = value;
+      this.wizardStep = 2;
+      this.showWizardStep();
+    } else {
+      // Final step (display name): commit the collected fields
+      this.wizardDialog = undefined;
+      void this.saveNewServer(this.wizardUrl, this.wizardId, value);
+      return;
+    }
+    this.options.tui.requestRender();
+  }
+
+  private cancelWizard(): void {
+    this.wizardDialog = undefined;
+    this.mode = "list";
+    this.options.tui.requestRender();
+  }
+
+  private async saveNewServer(
+    url: string,
+    id: string,
+    name: string,
+  ): Promise<void> {
+    const next = [
+      ...this.options.servers,
+      {
+        url,
+        ...(id.length > 0 ? { id } : {}),
+        ...(name.length > 0 ? { name } : {}),
+      },
+    ];
+    try {
+      await this.options.persist(next);
+      // Adopt the persisted list and rebuild so the new row appears;
+      // the new server is appended last — put the cursor on it
+      this.options.servers = next;
+      await this.rebuildList(next.length - 1);
+      this.mode = "list";
+    } catch (err) {
+      this.options.onError(String(err));
+      this.mode = "list";
+    }
+    this.options.tui.requestRender();
+  }
+
+  // -- delete ------------------------------------------------------------------
+
+  private beginConfirm(): void {
+    const server = this.options.servers[this.selectedIndex()];
+    if (!server) return;
+
+    this.mode = "confirm";
+    this.confirmDialog = new ConfirmDialog({
+      theme: this.options.theme,
+      tui: this.options.tui,
+      title: TITLES.deleteServer,
+      message: `Delete "${server.url}"?`,
+      onConfirm: () => {
+        this.confirmDialog = undefined;
+        void this.deleteSelected();
+      },
+      onCancel: () => {
+        this.confirmDialog = undefined;
+        this.mode = "list";
+        this.options.tui.requestRender();
+      },
+    });
+    this.confirmDialog.focused = this.isFocused;
+    this.options.tui.requestRender();
+  }
+
+  private async deleteSelected(): Promise<void> {
+    const idx = this.selectedIndex();
+    const servers = this.options.servers;
+    const next = servers.filter((_, i) => i !== idx);
+    try {
+      await this.options.persist(next);
+      // Adopt the persisted list and rebuild so the row disappears;
+      // the server that followed the deleted one now sits at the same
+      // index (rebuildList clamps when the last row was deleted)
+      this.options.servers = next;
+      await this.rebuildList(idx);
+      this.mode = "list";
+    } catch (err) {
+      this.options.onError(String(err));
+      this.mode = "list";
+    }
+    this.options.tui.requestRender();
+  }
+
+  private async handleFieldChange(field: string, value: string): Promise<void> {
+    const idx = this._selectedIndex;
+    const server = this.options.servers[idx];
+    if (!server) return;
+
+    const next = this.options.servers.map((s, i) => {
+      if (i !== idx) return s;
+      if (field === "url") return { ...s, url: value };
+      if (field === "id") {
+        const { id, ...rest } = s;
+        return value.length === 0 ? rest : { ...rest, id: value };
+      }
+      const { name, ...rest } = s;
+      return value.length === 0 ? rest : { ...rest, name: value };
+    });
+
+    try {
+      await this.options.persist(next);
+      // URL/id/name changes alter row labels → rebuild the list;
+      // keep the cursor on the edited server
+      this.options.servers = next;
+      await this.rebuildList(idx);
+      this.options.tui.requestRender();
+    } catch (err) {
+      this.options.onError(String(err));
+      this.options.tui.requestRender();
+    }
+  }
+}

package/src/ui/strings.ts

@@ -0,0 +1,127 @@
+import { LLAMA_SERVER_URL } from "../constants";
+
+/**
+ * Shared user-facing wording for the UI editors. Centralizing these keeps
+ * every concept named consistently across row labels, dialog titles,
+ * prompts, descriptions and hints — e.g. `Pattern` always carries the
+ * `'startsWith'` matching note, so the field is never ambiguous.
+ */
+
+/** Definition of one editable field, as shown to the user. */
+export interface Field {
+  /** Term for the field, used as `SettingItem` label and composed into
+   * dialog titles (`Edit ${field.label}`). */
+  label: string;
+  /** Parenthetical appended to the field's dialog prompt. */
+  note?: string;
+  /** Row description in the containing `SettingsList`. */
+  description: string;
+  /** Example value shown dim as `e.g., <placeholder>` in input dialogs. */
+  placeholder?: string;
+}
+
+/** Every editable field, as shown to the user. The single source of
+ * truth for a field's label, row description, dialog prompt and
+ * placeholder.
+ */
+export const FIELDS = {
+  pattern: {
+    label: "Pattern",
+    note: "(using 'startsWith')",
+    description: "Model id prefix (longest match wins - uses 'startsWith')",
+    placeholder: "qwen-3",
+  },
+  serverUrl: {
+    label: "Server URL",
+    description: "Server URL (http://host or http://host:port)",
+    placeholder: LLAMA_SERVER_URL,
+  },
+  providerId: {
+    label: "Provider ID",
+    note: "(empty uses auto-detected)",
+    description: "Provider ID (empty uses auto-detected)",
+    placeholder: "llama-local",
+  },
+  displayName: {
+    label: "Display name",
+    description: "Custom display name",
+    placeholder: "Local workstation",
+  },
+  inputCost: {
+    label: "Input cost",
+    note: "(per 1M tokens)",
+    description: "Token cost per 1M input tokens",
+    placeholder: "0.15",
+  },
+  outputCost: {
+    label: "Output cost",
+    note: "(per 1M tokens)",
+    description: "Token cost per 1M output tokens",
+    placeholder: "0.6",
+  },
+  cacheReadCost: {
+    label: "Cache read cost",
+    note: "(per 1M tokens)",
+    description: "Token cost per 1M cached tokens (read)",
+    placeholder: "0.01",
+  },
+  cacheWriteCost: {
+    label: "Cache write cost",
+    note: "(per 1M tokens)",
+    description: "Token cost per 1M cached tokens (write)",
+    placeholder: "0.02",
+  },
+  capabilities: {
+    label: "Capabilities",
+    description: "Model capabilities (replaces detected)",
+  },
+  reasoning: {
+    label: "Reasoning",
+    description: "Is this a reasoning model? (true = default)",
+  },
+  contextSize: {
+    label: "Context size",
+    note: "(0 = autodetect)",
+    description: "Override detected context size (0 = autodetect)",
+    placeholder: "32768",
+  },
+  maxTokens: {
+    label: "Max tokens",
+    note: "(0 = autodetect)",
+    description: "Override max generation tokens (0 = autodetect)",
+    placeholder: "4096",
+  },
+} as const satisfies Record<string, Field>;
+
+/** Dialog prompt for a field: the `label` plus its parenthetical `note`
+ * (or an overriding note, e.g. the add-server wizard's "(optional)").
+ */
+export const fieldMessage = (field: Field, note = field.note): string =>
+  note ? `${field.label} ${note}` : field.label;
+
+/**
+ * Dialog titles. `edit` composes the shared `Edit <term>` title so the
+ * phrasing stays uniform across all field submenus; `addServerStep`
+ * formats the add-server wizard's step counter.
+ */
+export const TITLES = {
+  edit: (term: string) => `Edit ${term}`,
+  addServerStep: (step: 1 | 2 | 3) => `Add server · ${step}/3`,
+  addOverride: "Add override",
+  deleteServer: "Delete server",
+  deleteOverride: "Delete override",
+} as const;
+
+/** Keybinding hint lines shared by the editors' lists */
+export const HINTS = {
+  /** Row description for an editable server in the `/models servers` list */
+  serverRow:
+    "Enter: edit URL/id/name · (a) add server · (d) delete · Esc: done",
+  /** Row description for an override entry in the per-server entry list */
+  overrideEntryRow:
+    "Enter: edit fields · (a) add override · (d) delete · Esc back",
+  /** Hint line when the servers list is empty (no rows → no description) */
+  emptyServers: "  (a) add server · Esc done",
+  /** Hint line when the override entry list is empty */
+  emptyOverrideEntries: "  (a) add override · Esc back",
+} as const;

package/src/utils/health.ts

@@ -0,0 +1,48 @@
+import { ServerStatus } from "../enums/serverStatus";
+
+/**
+ * Probes a llama-server's `/health` endpoint and classifies the outcome.
+ *
+ * The single source of truth for health classification — both
+ * `Server.isReady` and the UI health indicators delegate here.
+ *
+ * - HTTP success with `{ status: "ok" }`  → `READY`
+ * - The request is still in flight when the deadline passes
+ *   (`AbortSignal.timeout` aborts it)     → `TIMEOUT`
+ * - Anything else (network error, non-JSON or non-ok payload)
+ *                                         → `UNREACHABLE`
+ *
+ * The HTTP status code itself is not inspected: a llama-server answers
+ * `/health` with the payload's `status` field, and both classification
+ * branches key off it (matching the behavior of `ApiClient.get`, which
+ * also ignores status codes and parses the body).
+ *
+ * @param url The bare origin of the llama-server (the endpoint is
+ *   `<url>/health`, without the `/v1` prefix)
+ * @param timeout Maximum time (ms) to wait for the health check
+ * @param apiKey Optional API key, sent as a Bearer token — servers
+ *   behind an API-key gate would otherwise report UNREACHABLE
+ * @returns The classified server status
+ */
+export const checkServerHealth = async (
+  url: string,
+  timeout: number,
+  apiKey?: string,
+): Promise<ServerStatus> => {
+  try {
+    const response = await fetch(`${url}/health`, {
+      signal: AbortSignal.timeout(timeout),
+      headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : undefined,
+    });
+    const data = (await response.json()) as { status?: string };
+    return data.status === "ok" ? ServerStatus.READY : ServerStatus.UNREACHABLE;
+  } catch (error) {
+    // `AbortSignal.timeout` rejects `fetch` with a `TimeoutError`
+    // DOMException (some runtimes surface it as `AbortError` with a
+    // timeout message).
+    const isTimeout =
+      error instanceof Error &&
+      (error.name === "TimeoutError" || error.name === "AbortError");
+    return isTimeout ? ServerStatus.TIMEOUT : ServerStatus.UNREACHABLE;
+  }
+};

package/src/utils/settingsStore.ts

@@ -1,9 +1,7 @@
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { readFile, rename, writeFile } from "node:fs/promises";
-import { join } from "node:path";
 
 /**
- * Read/write access to pi's global settings.json on behalf of this extension.
+ * Read/write access to a settings.json file on behalf of this extension.
  * Owns serialization of writes and atomicity; knows nothing about pi's
  * SettingsManager.
  */
@@ -11,9 +9,7 @@ export class SettingsStore {
   /** Serializes whole-file read-modify-write cycles (last write wins). */
   private writeQueue: Promise<void> = Promise.resolve();
 
-  constructor(
-    private readonly path: string = join(getAgentDir(), "settings.json"),
-  ) {}
+  constructor(private readonly path: string) {}
 
   /**
    * Reads and parses the whole settings file.