pi-llama-cpp 0.14.0 → 0.16.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/tests/utils/credentialResolver.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from "vitest";
+import { CredentialResolver } from "../../src/utils/credentialResolver";
+
+describe("CredentialResolver", () => {
+  const resolver = new CredentialResolver();
+
+  describe("resolve", () => {
+    it("returns placeholder for empty key", () => {
+      expect(resolver.resolve("")).toBe("sk-placeholder");
+      expect(resolver.resolve(undefined as any)).toBe("sk-placeholder");
+    });
+
+    it("returns literal key as-is", () => {
+      expect(resolver.resolve("sk-abc123")).toBe("sk-abc123");
+      expect(resolver.resolve("plain-key-without-dollars")).toBe(
+        "plain-key-without-dollars",
+      );
+    });
+
+    it("resolves escape sequences $$", () => {
+      expect(resolver.resolve("$$literal")).toBe("$literal");
+    });
+
+    it("resolves escape sequences $!", () => {
+      expect(resolver.resolve("$!bang")).toBe("!bang");
+    });
+
+    it("resolves $VAR from credential.env", () => {
+      expect(resolver.resolve("$MY_KEY", { MY_KEY: "from-env" })).toBe(
+        "from-env",
+      );
+    });
+
+    it("resolves ${VAR} from credential.env", () => {
+      expect(resolver.resolve("${MY_KEY}", { MY_KEY: "from-env" })).toBe(
+        "from-env",
+      );
+    });
+
+    it("resolves $VAR from process.env as fallback", () => {
+      process.env.TEST_PROCESS_VAR = "process-value";
+      expect(resolver.resolve("$TEST_PROCESS_VAR")).toBe("process-value");
+      delete process.env.TEST_PROCESS_VAR;
+    });
+
+    it("prioritizes credential.env over process.env", () => {
+      process.env.PREF_KEY = "process-value";
+      expect(
+        resolver.resolve("$PREF_KEY", { PREF_KEY: "credential-value" }),
+      ).toBe("credential-value");
+      delete process.env.PREF_KEY;
+    });
+
+    it("returns placeholder when env var is missing", () => {
+      expect(resolver.resolve("$UNSET_VAR")).toBe("sk-placeholder");
+      expect(resolver.resolve("${UNSET_VAR}", { OTHER_KEY: "value" })).toBe(
+        "sk-placeholder",
+      );
+    });
+
+    it("returns placeholder for invalid env var syntax", () => {
+      expect(resolver.resolve("$123invalid")).toBe("sk-placeholder");
+      expect(resolver.resolve("$has-dash")).toBe("sk-placeholder");
+    });
+  });
+});

package/tests/utils/urlResolver.test.ts

@@ -0,0 +1,116 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { UrlResolver } from "../../src/utils/urlResolver";
+
+function createResolver(
+  getLlamaSettings: () => Promise<Record<string, unknown>>,
+  getMergedSettings: () => Promise<Record<string, unknown>>,
+) {
+  return new UrlResolver({ getLlamaSettings, getMergedSettings });
+}
+
+describe("UrlResolver", () => {
+  beforeEach(() => {
+    delete process.env.LLAMA_SERVER_URL;
+  });
+
+  describe("resolveUrls", () => {
+    it("falls back to default when nothing is configured", async () => {
+      const resolver = createResolver(
+        () => Promise.resolve({}),
+        () => Promise.resolve({}),
+      );
+
+      const result = await resolver.resolveUrls();
+      expect(result).toEqual(["http://127.0.0.1:8080"]);
+    });
+
+    it("prioritizes env variable over all config sources", async () => {
+      process.env.LLAMA_SERVER_URL = "http://env:9090";
+      const resolver = createResolver(
+        () =>
+          Promise.resolve({
+            servers: [{ url: "http://servers:8080" }],
+          }),
+        () => Promise.resolve({ llamaServerUrl: "http://legacy:7070" }),
+      );
+
+      const result = await resolver.resolveUrls();
+      expect(result).toEqual(["http://env:9090"]);
+    });
+
+    it("prioritizes llamaSettings.servers over legacy llamaServerUrl", async () => {
+      const resolver = createResolver(
+        () =>
+          Promise.resolve({
+            servers: [{ url: "http://servers:8080" }],
+          }),
+        () => Promise.resolve({ llamaServerUrl: "http://legacy:7070" }),
+      );
+
+      const result = await resolver.resolveUrls();
+      expect(result).toEqual(["http://servers:8080"]);
+    });
+
+    it("falls back to legacy when servers is empty", async () => {
+      const resolver = createResolver(
+        () => Promise.resolve({ servers: [] }),
+        () => Promise.resolve({ llamaServerUrl: "http://legacy:7070" }),
+      );
+
+      const result = await resolver.resolveUrls();
+      expect(result).toEqual(["http://legacy:7070"]);
+    });
+
+    it("returns empty arrays from settings when values are falsy", async () => {
+      const resolver = createResolver(
+        () => Promise.resolve({ servers: undefined }),
+        () => Promise.resolve({ llamaServerUrl: undefined }),
+      );
+
+      const result = await resolver.resolveUrls();
+      expect(result).toEqual(["http://127.0.0.1:8080"]);
+    });
+  });
+
+  describe("warnings", () => {
+    it("collects warnings for invalid env URLs", async () => {
+      process.env.LLAMA_SERVER_URL = "invalid-url;http://good:8080";
+      const resolver = createResolver(
+        () => Promise.resolve({}),
+        () => Promise.resolve({}),
+      );
+
+      await resolver.resolveUrls();
+      expect(resolver.takeWarnings()).toEqual([
+        "Ignoring invalid server URL 'invalid-url' (needs http(s)://)",
+      ]);
+    });
+
+    it("collects warnings for invalid server URLs", async () => {
+      const resolver = createResolver(
+        () =>
+          Promise.resolve({
+            servers: [{ url: "bad-url" }, { url: "http://good:8080" }],
+          }),
+        () => Promise.resolve({}),
+      );
+
+      await resolver.resolveUrls();
+      expect(resolver.takeWarnings()).toEqual([
+        "Ignoring invalid server URL 'bad-url' (needs http(s)://)",
+      ]);
+    });
+
+    it("clears warnings after takeWarnings()", async () => {
+      process.env.LLAMA_SERVER_URL = "bad;http://good:8080";
+      const resolver = createResolver(
+        () => Promise.resolve({}),
+        () => Promise.resolve({}),
+      );
+
+      await resolver.resolveUrls();
+      expect(resolver.takeWarnings()).toHaveLength(1);
+      expect(resolver.takeWarnings()).toEqual([]);
+    });
+  });
+});

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(", ") : "—";
-  }
-}