pi-llama-cpp 0.14.0 → 0.15.0

package/tests/{settingsStore.test.ts → settings/settingsStore.test.ts}

@@ -1,5 +1,5 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import { SettingsStore } from "../src/utils/settingsStore";
+import { SettingsStore } from "../../src/utils/settingsStore";
 
 const mockReadFile = vi.hoisted(() => vi.fn());
 const mockWriteFile = vi.hoisted(() => vi.fn());

package/tests/{sseManager.test.ts → sse/sseManager.test.ts}

@@ -1,6 +1,6 @@
 import { describe, expect, it, vi } from "vitest";
-import { SSEManager } from "../src/sse/manager";
-import { createMockServer } from "./mocks";
+import { SSEManager } from "../../src/sse/manager";
+import { createMockServer } from "../mocks";
 
 /**
  * Builds an SSEManager bound to a stub server, mirroring how

package/tests/{dialog.test.ts → ui/dialog.test.ts}

@@ -5,10 +5,10 @@ import {
   type TUI,
 } from "@earendil-works/pi-tui";
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import { ConfirmDialog } from "../src/ui/dialog/confirm";
-import { InputDialog } from "../src/ui/dialog/input";
-import { OverrideSettingsList } from "../src/ui/editors/override/overrideList";
-import { ServerSettingsList } from "../src/ui/editors/server/serverEditor";
+import { ConfirmDialog } from "../../src/ui/dialog/confirm";
+import { InputDialog } from "../../src/ui/dialog/input";
+import { OverrideSettingsList } from "../../src/ui/editors/override/overrideList";
+import { ServerSettingsList } from "../../src/ui/editors/server/serverEditor";
 
 beforeEach(() => {
   initTheme();
@@ -139,6 +139,7 @@ describe("ServerSettingsList add wizard", () => {
       persist,
       done,
       onError,
+      authResolver: () => Promise.resolve("sk-placeholder"),
     });
     return { editor, persist, done, onError };
   };

package/tests/{overrides.test.ts → ui/overrides.test.ts}

@@ -1,15 +1,14 @@
 import { beforeEach, describe, expect, it } from "vitest";
-import { FALLBACK_CTX } from "../src/constants";
-import type { LlamaServer, ModelOverride } from "../src/interfaces/settings";
-import { SingleModel } from "../src/models/singleModel";
-import { Server } from "../src/server";
-import { OverrideEntry } from "../src/ui/editors/override/entry";
+import { FALLBACK_CTX } from "../../src/constants";
+import type { ModelOverride } from "../../src/interfaces/settings";
+import { SingleModel } from "../../src/models/singleModel";
+import { Server } from "../../src/server";
+import { OverrideEntry } from "../../src/ui/editors/override/entry";
 import {
   OverrideFields,
   OverrideSummary,
-} from "../src/ui/editors/override/fields";
-import { OverrideEntryMutator } from "../src/ui/editors/override/handlers";
-import { createMockServer, mockRpc } from "./mocks";
+} from "../../src/ui/editors/override/fields";
+import { createMockServer, mockRpc } from "../mocks";
 
 beforeEach(() => {
   mockRpc.mockReset();
@@ -293,41 +292,9 @@ describe("OverrideSummary.of", () => {
   });
 });
 
-// ─── override entry list helpers (overrideEntryEditor) ────────────────────
-
-describe("override entry list helpers", () => {
-  const servers = [
-    { url: "http://a", overrides: { "a-1": { reasoning: false } } },
-    { url: "http://b" },
-  ] as LlamaServer[];
-
-  it("addEntry should append a pattern → override entry", () => {
-    const next = new OverrideEntryMutator(servers, 0).addEntry("a-2", {
-      contextSize: 4096,
-    });
-    expect(next[0].overrides).toEqual({
-      "a-1": { reasoning: false },
-      "a-2": { contextSize: 4096 },
-    });
-  });
-
-  it("pattern renames should replace in place without reordering", () => {
-    const mutator = new OverrideEntryMutator(servers, 0);
-    const result = mutator.applyFieldChange(0, "pattern", "a-renamed");
-    expect(result).not.toBeNull();
-    expect(Object.keys(result!.next[0].overrides!)).toEqual(["a-renamed"]);
-    expect(result!.next[0].overrides!["a-renamed"]).toEqual({
-      reasoning: false,
-    });
-    expect(result!.next[1]).toBe(servers[1]);
-  });
-
-  it("removeEntry should drop only the targeted entry", () => {
-    const withTwo = new OverrideEntryMutator(servers, 0).addEntry("a-2");
-    const next = new OverrideEntryMutator(withTwo, 0).removeEntry(0);
-    expect(Object.keys(next[0].overrides!)).toEqual(["a-2"]);
-  });
+// ─── CostField tests ──────────────────────────────────────────────────────
 
+describe("CostField validation and apply", () => {
   it("CostField.validate should accept blank, non-negative numbers; reject the rest", () => {
     const cost = OverrideFields.byId("cost.input");
     expect(cost.validate("")).toBe("0");

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

@@ -1,294 +0,0 @@
-import type { ModelCost, ModelCostRates } from "@earendil-works/pi-ai";
-import type { ModelOverride } from "../../../interfaces/settings";
-import { FIELDS, type Field } from "../../strings";
-import { SettingField } from "../settingField";
-import { OverrideEntry } from "./entry";
-
-/** Type of a field: "input" for free-text, "finite" for fixed options */
-export type FieldType = "input" | "finite";
-
-/** Validation function for input fields */
-export type InputValidator = (raw: string) => string | null;
-
-/**
- * Abstract base class for one editable field of a model override entry
- * (Template Method): each subclass owns its display format, validation
- * and apply logic in a single place, so the parse/format round-trips
- * can't drift. Extends the shared {@link SettingField} base (id, label,
- * description, placeholder from the FIELDS registry).
- */
-export abstract class OverrideField extends SettingField<OverrideEntry> {
-  /** Field type: "input" for free-text, "finite" for fixed options. */
-  abstract readonly type: FieldType;
-
-  /**
-   * Canonical display label for this field — the single source of truth
-   * for both the field rows' `currentValue` and the post-commit refresh
-   * of an open field submenu, so the two can't drift.
-   */
-  abstract displayValue(entry: OverrideEntry): string;
-
-  /** Current value shown in the row — same rendering as the post-commit
-   * refresh of an open field submenu, so the two can't drift. */
-  currentValue(entry: OverrideEntry): string {
-    return this.displayValue(entry);
-  }
-
-  /** For "input" fields: validation function for committed values. */
-  abstract readonly validate: InputValidator;
-
-  /** For "finite" fields: the fixed options (undefined for "input"). */
-  readonly options: readonly string[] | undefined = undefined;
-
-  /** Applies a committed value to the override object. The pattern key
-   * rename is handled separately by the mutator. */
-  abstract apply(override: ModelOverride, value: string): void;
-
-  /** One `term: value` part of the entry-row summary (see
-   * {@link OverrideSummary.of}), or `null` when the field shouldn't
-   * appear (unset/zero values — each field decides). The pattern is the
-   * row label, so it never contributes a part; the default is `null`. */
-  summaryPart(_override: ModelOverride): string | null {
-    return null;
-  }
-
-  /** Parses a non-negative number; blank input means zero (unset fields
-   * default to zero at read time). Returns `null` when invalid. Shared
-   * by the cost and numeric fields so their validation can't drift. */
-  protected static parseNonNegative(raw: string): number | null {
-    const n = Number(raw.trim());
-    return isFinite(n) && n >= 0 ? n : null;
-  }
-}
-
-/**
- * The entry's pattern key. The rename itself is handled by the mutator
- * (`OverrideEntryMutator`); {@link apply} is a no-op.
- */
-class PatternField extends OverrideField {
-  readonly id = "pattern";
-  readonly type = "input";
-  readonly field = FIELDS.pattern;
-
-  displayValue(entry: OverrideEntry): string {
-    return entry.pattern;
-  }
-
-  readonly validate: InputValidator = (raw) => {
-    const trimmed = raw.trim();
-    return trimmed.length > 0 ? trimmed : null;
-  };
-
-  apply(): void {
-    // The pattern IS the map key — renames go through the mutator.
-  }
-}
-
-/**
- * One `ModelCostRates` key of the override's `cost` object (absorbs the
- * former `CostFieldDefFactory` and the standalone `parseCostValue` /
- * `applyCostFieldValue` helpers): owns the cost parse and immutable
- * apply in the same place as its display format.
- */
-class CostField extends OverrideField {
-  readonly type = "input";
-  override readonly field: Field;
-
-  constructor(
-    readonly id: string,
-    private readonly key: keyof ModelCostRates,
-    field: Field,
-    /** Short term used in the entry-row summary (e.g. `cache read`). */
-    private readonly summaryTerm: string,
-  ) {
-    super();
-    this.field = field;
-  }
-
-  displayValue(entry: OverrideEntry): string {
-    return String(entry.override.cost?.[this.key] ?? 0);
-  }
-
-  readonly validate: InputValidator = (raw) => {
-    const parsed = OverrideField.parseNonNegative(raw);
-    return parsed === null ? null : String(parsed);
-  };
-
-  apply(override: ModelOverride, value: string): void {
-    const nextCost = this.applyCost(override.cost, Number(value));
-    if (nextCost) override.cost = nextCost;
-    else delete override.cost;
-  }
-
-  /** Returns a copy of `cost` with this field set to `value`. A `0` (or
-   * non-finite) value removes the field — unset cost fields default to
-   * zero at read time — and when no fields remain, returns `undefined`
-   * so the whole `cost` object can be dropped. Immutable. */
-  private applyCost(
-    cost: ModelOverride["cost"],
-    value: number,
-  ): Partial<ModelCost> | undefined {
-    const next = { ...cost };
-    if (isFinite(value) && value > 0) next[this.key] = value;
-    else delete next[this.key];
-    return Object.keys(next).length > 0 ? next : undefined;
-  }
-
-  /** Appears in the summary only when a non-zero cost is set. */
-  override summaryPart(override: ModelOverride): string | null {
-    const value = override.cost?.[this.key];
-    return value ? `${this.summaryTerm}: $${value}` : null;
-  }
-}
-
-/**
- * Non-negative numeric field (`contextSize`, `maxTokens`): keeps the
- * display format, validator and apply logic in a single place so the
- * three can't drift (e.g. the validator accepting `0` while the apply
- * drops it — unset fields default to zero at read time, so all render
- * as `0`).
- */
-class NumericField extends OverrideField {
-  readonly type = "input";
-  override readonly field: Field;
-
-  constructor(
-    readonly id: "maxTokens" | "contextSize",
-    field: Field,
-  ) {
-    super();
-    this.field = field;
-  }
-
-  displayValue(entry: OverrideEntry): string {
-    return String(entry.override[this.id] ?? 0);
-  }
-
-  /** Accepts finite, non-negative numbers (blank means zero). */
-  readonly validate: InputValidator = (raw) => {
-    const n = OverrideField.parseNonNegative(raw);
-    return n === null ? null : String(n);
-  };
-
-  /** Applies the committed value; non-positive values remove the key. */
-  apply(override: ModelOverride, value: string): void {
-    const n = Number(value);
-    if (isFinite(n) && n > 0) override[this.id] = n;
-    else delete override[this.id];
-  }
-
-  /** Appears in the summary only when set. */
-  override summaryPart(override: ModelOverride): string | null {
-    const value = override[this.id];
-    return value === undefined ? null : `${this.id}: ${value}`;
-  }
-}
-
-/** The override's `capabilities` list (finite: fixed label options). */
-class CapabilitiesField extends OverrideField {
-  readonly id = "capabilities";
-  readonly type = "finite";
-  readonly field = FIELDS.capabilities;
-  override readonly options = ["text", "text | image"];
-
-  displayValue(entry: OverrideEntry): string {
-    return entry.override.capabilities?.join(" | ") ?? "text";
-  }
-
-  readonly validate: InputValidator = (raw) =>
-    this.options?.includes(raw) ? raw : null;
-
-  apply(override: ModelOverride, value: string): void {
-    override.capabilities =
-      value === "text | image"
-        ? ["text", "image"]
-        : value === "text"
-          ? ["text"]
-          : undefined;
-  }
-
-  /** Appears in the summary only when non-empty. */
-  override summaryPart(override: ModelOverride): string | null {
-    return override.capabilities?.length
-      ? `capabilities: ${override.capabilities.join(",")}`
-      : null;
-  }
-}
-
-/** The override's `reasoning` flag (finite: true/false, default true). */
-class ReasoningField extends OverrideField {
-  readonly id = "reasoning";
-  readonly type = "finite";
-  readonly field = FIELDS.reasoning;
-  override readonly options = ["true", "false"];
-
-  displayValue(entry: OverrideEntry): string {
-    return entry.override.reasoning === false ? "false" : "true";
-  }
-
-  readonly validate: InputValidator = (raw) =>
-    this.options?.includes(raw) ? raw : null;
-
-  apply(override: ModelOverride, value: string): void {
-    if (value === "true") override.reasoning = true;
-    else if (value === "false") override.reasoning = false;
-    else delete override.reasoning;
-  }
-
-  /** Appears in the summary only when explicitly set. */
-  override summaryPart(override: ModelOverride): string | null {
-    return override.reasoning === undefined
-      ? null
-      : `reasoning: ${override.reasoning}`;
-  }
-}
-
-/** Cost field specs: [ModelCostRates key, FIELDS entry, summary term] */
-const COST_FIELDS: [keyof ModelCostRates, Field, string][] = [
-  ["input", FIELDS.inputCost, "input"],
-  ["output", FIELDS.outputCost, "output"],
-  ["cacheRead", FIELDS.cacheReadCost, "cache read"],
-  ["cacheWrite", FIELDS.cacheWriteCost, "cache write"],
-];
-
-/**
- * The field registry for model override entries: the complete list of
- * editable fields (order defines the row order in the settings list)
- * plus id-based lookup. Throws on an unknown id — the registry is
- * static, so a miss is a programming error.
- */
-export class OverrideFields {
-  static readonly all: OverrideField[] = [
-    new PatternField(),
-    ...COST_FIELDS.map(
-      ([key, field, term]) => new CostField(`cost.${key}`, key, field, term),
-    ),
-    new CapabilitiesField(),
-    new ReasoningField(),
-    new NumericField("contextSize", FIELDS.contextSize),
-    new NumericField("maxTokens", FIELDS.maxTokens),
-  ];
-
-  static byId(id: string): OverrideField {
-    const field = this.all.find((f) => f.id === id);
-    if (!field) throw new Error(`Unknown override field: ${id}`);
-    return field;
-  }
-}
-
-/**
- * Builds the entry-row summary shown in the override entry list
- * (`input: $0.2, output: $0.6, cache read: $0.01, …`), composed from the
- * {@link OverrideFields} registry — adding a field to the registry makes
- * it show up here too, so the summary can't lag the edit menu. Fields
- * with unset/zero values are omitted for brevity (each field decides via
- * {@link OverrideField.summaryPart}); `—` when nothing is set.
- */
-export class OverrideSummary {
-  static of(override: ModelOverride): string {
-    const parts = OverrideFields.all
-      .map((field) => field.summaryPart(override))
-      .filter((part): part is string => part !== null);
-    return parts.length > 0 ? parts.join(", ") : "—";
-  }
-}

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

@@ -1,118 +0,0 @@
-import type { LlamaServer, ModelOverride } from "../../../interfaces/settings";
-import { OverrideEntry } from "./entry";
-import { OverrideFields } from "./fields";
-
-/** Result of applying a field change: the next server list and the
- * updated override for UI refresh. `null` when the entry doesn't exist
- * (stale index — a no-op). */
-export interface MutationResult {
-  next: LlamaServer[];
-  updatedOverride: ModelOverride;
-}
-
-/**
- * Applies edits (field commits, entry adds/renames/removals) to the
- * override entries of a single server, immutably. Binds the server list
- * and server index once in the constructor so call sites don't juggle
- * long positional lists.
- *
- * Per-field commit behavior lives in the {@link OverrideFields} registry
- * (`apply` on each field instance) — this class only resolves the field
- * and the entry, and handles the pattern rename specially.
- */
-export class OverrideEntryMutator {
-  constructor(
-    private readonly servers: LlamaServer[],
-    private readonly serverIndex: number,
-  ) {}
-
-  /** The server's override entries, in map iteration order. */
-  entries(): OverrideEntry[] {
-    return OverrideEntry.listFrom(this.servers[this.serverIndex]);
-  }
-
-  /** Handles a field commit from an override entry's submenu. Returns
-   * `null` when the entry doesn't exist (stale index — no-op). */
-  applyFieldChange(
-    entryIndex: number,
-    field: string,
-    value: string,
-  ): MutationResult | null {
-    const entry = this.entries()[entryIndex];
-    if (!entry) return null;
-
-    // Pattern field: rename the pattern key, keep the override object
-    if (field === "pattern") {
-      return {
-        next: this.updateEntry(entryIndex, value, entry.override),
-        updatedOverride: entry.override,
-      };
-    }
-
-    // Other fields: let the field definition apply itself
-    const updatedOverride: ModelOverride = { ...entry.override };
-    OverrideFields.byId(field).apply(updatedOverride, value);
-
-    return {
-      next: this.updateEntry(entryIndex, entry.pattern, updatedOverride),
-      updatedOverride,
-    };
-  }
-
-  /** Adds a new override entry with a uniquified pattern. */
-  addEntry(pattern: string, override: ModelOverride = {}): LlamaServer[] {
-    const server = this.servers[this.serverIndex];
-    if (!server) return this.servers;
-
-    const existing = new Set(Object.keys(server.overrides ?? {}));
-    let uniquePattern = pattern;
-    let n = 2;
-    while (existing.has(uniquePattern)) {
-      uniquePattern = `${pattern}-${n++}`;
-    }
-
-    return this.withServer((s) => ({
-      ...s,
-      overrides: { ...s.overrides, [uniquePattern]: override },
-    }));
-  }
-
-  /** Removes the entry at `entryIndex`. */
-  removeEntry(entryIndex: number): LlamaServer[] {
-    return this.withServer((s) => ({
-      ...s,
-      overrides: Object.fromEntries(
-        Object.entries(s.overrides ?? {}).filter((_, j) => j !== entryIndex),
-      ),
-    }));
-  }
-
-  // -- internal helpers ------------------------------------------------------
-
-  /** Returns the servers with the target server replaced by
-   * `fn(server)`. Immutable. */
-  private withServer(fn: (server: LlamaServer) => LlamaServer): LlamaServer[] {
-    return this.servers.map((server, i) =>
-      i === this.serverIndex ? fn(server) : server,
-    );
-  }
-
-  /** Replaces the entry at `entryIndex` with `pattern → override` in a
-   * single mutation — used both for renaming the pattern and for editing
-   * its fields. The entry keeps its position in the map's iteration
-   * order. Immutable. */
-  private updateEntry(
-    entryIndex: number,
-    pattern: string,
-    override: ModelOverride,
-  ): LlamaServer[] {
-    return this.withServer((s) => ({
-      ...s,
-      overrides: Object.fromEntries(
-        Object.entries(s.overrides ?? {}).map(([k, v], j) =>
-          j === entryIndex ? [pattern, override] : [k, v],
-        ),
-      ),
-    }));
-  }
-}

package/src/ui/editors/server/handlers.ts

@@ -1,32 +0,0 @@
-import type { LlamaServer } from "../../../interfaces/settings";
-import { ServerFields } from "./fields";
-
-/**
- * Applies field commits to a single server, immutably. Binds the server
- * list and server index once in the constructor so call sites don't
- * juggle long positional lists. Mirrors the override side's
- * `OverrideEntryMutator`.
- *
- * Per-field commit behavior lives in the `ServerFields` registry
- * (`apply` on each field class, backed by `LlamaServerBuilder`) — this
- * class only resolves the field definition and produces the next list.
- */
-export class ServerEntryMutator {
-  constructor(
-    private readonly servers: LlamaServer[],
-    private readonly serverIndex: number,
-  ) {}
-
-  /**
-   * Handles a field commit from a server row's submenu. Returns the
-   * next server list, or the same list when the server is missing
-   * (no-op — callers can compare by reference).
-   */
-  applyFieldChange(field: string, value: string): LlamaServer[] {
-    const server = this.servers[this.serverIndex];
-    if (!server) return this.servers;
-
-    const updated = ServerFields.byId(field).apply(server, value);
-    return this.servers.map((s, i) => (i === this.serverIndex ? updated : s));
-  }
-}