pi-llama-cpp 0.13.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
@@ -16,29 +16,15 @@ const createManager = (
       pollingTimeout,
       serverTimeout,
     }),
-    "",
   );
 
-describe("SSEManager timeouts", async () => {
-  it("should expose the timeouts of its server", async () => {
-    const manager = createManager(5678, 1234);
-
-    expect(await manager.getPollingTimeout()).toBe(5678);
-    expect(await manager.getServerTimeout()).toBe(1234);
-  });
-});
-
 describe("SSEManager subscribeToStatus", () => {
   it("should reject after the server's pollingTimeout, not the constant", async () => {
     vi.useFakeTimers();
+    // Never-resolving fetch: the connection stays open but no events arrive
     vi.stubGlobal(
-      "EventSource",
-      class StubEventSource {
-        onopen = null;
-        onerror = null;
-        onmessage = null;
-        close() {}
-      },
+      "fetch",
+      vi.fn(async () => new Promise<Response>(() => {})),
     );
 
     try {
@@ -60,14 +46,10 @@ describe("SSEManager subscribeToStatus", () => {
 
   it("should resolve when a terminal status arrives before the timeout", async () => {
     vi.useFakeTimers();
+    // Never-resolving fetch: events are dispatched manually below
     vi.stubGlobal(
-      "EventSource",
-      class StubEventSource {
-        onopen = null;
-        onerror = null;
-        onmessage = null;
-        close() {}
-      },
+      "fetch",
+      vi.fn(async () => new Promise<Response>(() => {})),
     );
 
     try {

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

@@ -5,9 +5,10 @@ import {
   type TUI,
 } from "@earendil-works/pi-tui";
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import { ConfirmDialog, InputDialog } from "../src/ui/dialog";
-import { createOverrideSettingsList } from "../src/ui/overrideSettingsList";
-import { ServerSettingsList } from "../src/ui/serverSettingsList";
+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();
@@ -138,6 +139,7 @@ describe("ServerSettingsList add wizard", () => {
       persist,
       done,
       onError,
+      authResolver: () => Promise.resolve("sk-placeholder"),
     });
     return { editor, persist, done, onError };
   };
@@ -191,7 +193,7 @@ describe("OverrideEntryListEditor cost re-prefill", () => {
 
   it("re-entering a cost field prefills the just-saved value", async () => {
     const persist = vi.fn().mockResolvedValue(undefined);
-    const list = createOverrideSettingsList({
+    const list = new OverrideSettingsList({
       tui: createMockTui(),
       theme: createMockTheme(),
       keybindings: createKeybindings(),
@@ -226,3 +228,53 @@ describe("OverrideEntryListEditor cost re-prefill", () => {
     expect(rendered).not.toContain("0.2");
   });
 });
+
+describe("OverrideSettingsList escape navigation", () => {
+  const flush = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+  const build = () => {
+    const done = vi.fn();
+    const list = new OverrideSettingsList({
+      tui: createMockTui(),
+      theme: createMockTheme(),
+      keybindings: createKeybindings(),
+      servers: [
+        {
+          url: "http://x:1",
+          overrides: { "gpt-*": { cost: { input: 0.2 } } },
+        },
+      ] as never[],
+      persist: vi.fn().mockResolvedValue(undefined),
+      done,
+      onError: vi.fn(),
+      onChanged: vi.fn(),
+    });
+    return { list, done };
+  };
+
+  it("Esc from the field submenu then the entry list lands on the server list", async () => {
+    const { list, done } = build();
+
+    list.handleInput(ENTER); // drill into the server row (entry list)
+    list.handleInput(ENTER); // open the field submenu
+    expect(list.render(80).join("\n")).not.toContain("http://x:1");
+
+    list.handleInput(ESC); // field submenu → entry list
+    await flush();
+    expect(done).not.toHaveBeenCalled();
+    expect(list.render(80).join("\n")).not.toContain("http://x:1");
+
+    list.handleInput(ESC); // entry list → server list
+    await flush();
+    // The dialog must stay open, showing the server row again
+    expect(done).not.toHaveBeenCalled();
+    expect(list.render(80).join("\n")).toContain("http://x:1");
+  });
+
+  it("Esc from the server list closes the dialog", async () => {
+    const { list, done } = build();
+
+    list.handleInput(ESC);
+    expect(done).toHaveBeenCalledTimes(1);
+  });
+});

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

@@ -1,18 +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 { 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 {
-  addOverrideEntry,
-  applyCostFieldValue,
-  formatOverrideSummary,
-  parseCostValue,
-  removeOverrideEntry,
-  updateOverrideEntry,
-} from "../src/ui/overrideEntryEditor";
-import { overrideFieldValue } from "../src/ui/overrideSettingsList";
-import { createMockServer, mockRpc } from "./mocks";
+  OverrideFields,
+  OverrideSummary,
+} from "../../src/ui/editors/override/fields";
+import { createMockServer, mockRpc } from "../mocks";
 
 beforeEach(() => {
   mockRpc.mockReset();
@@ -94,16 +90,18 @@ describe("BaseModel reasoning override", () => {
 
 // ─── capabilities override ────────────────────────────────────────────────
 
-describe("BaseModel capabilities override", () => {
+describe("BaseModel capabilities override (via toProviderConfig)", () => {
   it("should fully replace detection without contacting the server", async () => {
     mockRpc.mockImplementation(() => {
       throw new Error("override must not trigger a fetch");
     });
 
-    const model = createModel({ test: { capabilities: ["text", "image"] } });
-    const capabilities = await model.getCapabilities();
+    const model = createModel({
+      test: { capabilities: ["text", "image"], contextSize: 8192 },
+    });
+    const { input } = await model.toProviderConfig();
 
-    expect(capabilities).toEqual(["text", "image"]);
+    expect(input).toEqual(["text", "image"]);
     expect(mockRpc).not.toHaveBeenCalled();
   });
 
@@ -111,41 +109,41 @@ describe("BaseModel capabilities override", () => {
     mockDetection(8192);
 
     const model = createModel({ other: { capabilities: ["text"] } });
-    const capabilities = await model.getCapabilities();
+    const { input } = await model.toProviderConfig();
 
-    expect(capabilities).toEqual(["text"]);
+    expect(input).toEqual(["text"]);
     expect(mockRpc).toHaveBeenCalled();
   });
 });
 
 // ─── contextSize override ─────────────────────────────────────────────────
 
-describe("BaseModel.getContextSize with contextSize override", () => {
+describe("BaseModel contextSize override (via toProviderConfig)", () => {
   it("should return the overridden context size instead of the detected one", async () => {
     mockDetection(8192);
 
     const model = createModel({ test: { contextSize: 32768 } });
-    const ctxSize = await model.getContextSize();
+    const { contextWindow } = await model.toProviderConfig();
 
-    expect(ctxSize).toBe(32768);
+    expect(contextWindow).toBe(32768);
   });
 
   it("should treat a stored 0 as absent and autodetect", async () => {
     mockDetection(8192);
 
     const model = createModel({ test: { contextSize: 0 } });
-    const ctxSize = await model.getContextSize();
+    const { contextWindow } = await model.toProviderConfig();
 
-    expect(ctxSize).toBe(8192);
+    expect(contextWindow).toBe(8192);
   });
 
   it("should autodetect when no override matches", async () => {
     mockDetection(8192);
 
     const model = createModel({ other: { contextSize: 32768 } });
-    const ctxSize = await model.getContextSize();
+    const { contextWindow } = await model.toProviderConfig();
 
-    expect(ctxSize).toBe(8192);
+    expect(contextWindow).toBe(8192);
   });
 });
 
@@ -251,11 +249,14 @@ describe("toProviderConfig overrides", () => {
   });
 });
 
-// ─── formatOverrideSummary ────────────────────────────────────────────────
+// ─── OverrideEntry.summary ────────────────────────────────────────────────────
+
+describe("OverrideSummary.of", () => {
+  const summary = (override: ModelOverride): string =>
+    OverrideSummary.of(override);
 
-describe("formatOverrideSummary", () => {
   it("should render every configured field", () => {
-    const summary = formatOverrideSummary({
+    const rendered = summary({
       cost: { input: 0.2, output: 0.6, cacheRead: 0.01 },
       capabilities: ["text", "image"],
       reasoning: false,
@@ -263,122 +264,111 @@ describe("formatOverrideSummary", () => {
       maxTokens: 4096,
     });
 
-    expect(summary).toContain("input: $0.2");
-    expect(summary).toContain("output: $0.6");
-    expect(summary).toContain("cache read: $0.01");
-    expect(summary).toContain("capabilities: text,image");
-    expect(summary).toContain("reasoning: false");
-    expect(summary).toContain("contextSize: 32768");
-    expect(summary).toContain("maxTokens: 4096");
+    expect(rendered).toContain("input: $0.2");
+    expect(rendered).toContain("output: $0.6");
+    expect(rendered).toContain("cache read: $0.01");
+    expect(rendered).toContain("capabilities: text,image");
+    expect(rendered).toContain("reasoning: false");
+    expect(rendered).toContain("contextSize: 32768");
+    expect(rendered).toContain("maxTokens: 4096");
   });
 
   it("should omit zero, undefined and empty fields", () => {
-    const summary = formatOverrideSummary({
+    const rendered = summary({
       cost: { input: 0, output: 0.6 },
       reasoning: undefined,
     });
 
-    expect(summary).not.toContain("input:");
-    expect(summary).toContain("output: $0.6");
-    expect(summary).not.toContain("capabilities");
-    expect(summary).not.toContain("reasoning");
-    expect(summary).not.toContain("contextSize");
-    expect(summary).not.toContain("maxTokens");
+    expect(rendered).not.toContain("input:");
+    expect(rendered).toContain("output: $0.6");
+    expect(rendered).not.toContain("capabilities");
+    expect(rendered).not.toContain("reasoning");
+    expect(rendered).not.toContain("contextSize");
+    expect(rendered).not.toContain("maxTokens");
   });
 
   it("should render an em dash for an empty override", () => {
-    expect(formatOverrideSummary({})).toBe("—");
+    expect(summary({})).toBe("—");
   });
 });
 
-// ─── 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("addOverrideEntry should append a pattern → override entry", () => {
-    const next = addOverrideEntry(servers, 0, "a-2", { contextSize: 4096 });
-    expect(next[0].overrides).toEqual({
-      "a-1": { reasoning: false },
-      "a-2": { contextSize: 4096 },
-    });
-  });
-
-  it("updateOverrideEntry should replace in place without reordering", () => {
-    const next = updateOverrideEntry(servers, 0, 0, "a-renamed", {
-      reasoning: true,
-    });
-    expect(Object.keys(next[0].overrides!)).toEqual(["a-renamed"]);
-    expect(next[0].overrides!["a-renamed"]).toEqual({ reasoning: true });
-    expect(next[1]).toBe(servers[1]);
-  });
+// ─── CostField tests ──────────────────────────────────────────────────────
 
-  it("removeOverrideEntry should drop only the targeted entry", () => {
-    const withTwo = addOverrideEntry(servers, 0, "a-2", {});
-    const next = removeOverrideEntry(withTwo, 0, 0);
-    expect(Object.keys(next[0].overrides!)).toEqual(["a-2"]);
+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");
+    expect(cost.validate("  0.5 ")).toBe("0.5");
+    expect(cost.validate("-1")).toBeNull();
+    expect(cost.validate("abc")).toBeNull();
+    expect(cost.validate("Infinity")).toBeNull();
   });
 
-  it("parseCostValue should accept blank, non-negative numbers; reject the rest", () => {
-    expect(parseCostValue("")).toBe(0);
-    expect(parseCostValue("  0.5 ")).toBe(0.5);
-    expect(parseCostValue("-1")).toBeNull();
-    expect(parseCostValue("abc")).toBeNull();
-    expect(parseCostValue("Infinity")).toBeNull();
+  it("CostField.apply should set a positive value, keeping other fields", () => {
+    const override: ModelOverride = { cost: { input: 0.2 } };
+    OverrideFields.byId("cost.output").apply(override, "0.6");
+    expect(override.cost).toEqual({ input: 0.2, output: 0.6 });
   });
 
-  it("applyCostFieldValue should set a positive value, keeping other fields", () => {
-    const next = applyCostFieldValue({ input: 0.2 }, "output", 0.6);
-    expect(next).toEqual({ input: 0.2, output: 0.6 });
+  it("CostField.apply should remove the field on zero", () => {
+    const override: ModelOverride = { cost: { input: 0.2, output: 0.6 } };
+    OverrideFields.byId("cost.input").apply(override, "0");
+    expect(override.cost).toEqual({ output: 0.6 });
   });
 
-  it("applyCostFieldValue should remove the field on zero", () => {
-    const next = applyCostFieldValue({ input: 0.2, output: 0.6 }, "input", 0);
-    expect(next).toEqual({ output: 0.6 });
-  });
+  it("CostField.apply should drop the whole cost object when the last field is zeroed", () => {
+    const single: ModelOverride = { cost: { input: 0.2 } };
+    OverrideFields.byId("cost.input").apply(single, "0");
+    expect(single.cost).toBeUndefined();
 
-  it("applyCostFieldValue should return undefined when the last field is zeroed", () => {
-    expect(applyCostFieldValue({ input: 0.2 }, "input", 0)).toBeUndefined();
-    expect(applyCostFieldValue(undefined, "input", 0)).toBeUndefined();
+    const empty: ModelOverride = {};
+    OverrideFields.byId("cost.input").apply(empty, "0");
+    expect(empty.cost).toBeUndefined();
   });
 
-  it("applyCostFieldValue should treat an empty override as unset cost", () => {
-    expect(applyCostFieldValue(undefined, "input", 0.5)).toEqual({
-      input: 0.5,
-    });
+  it("CostField.apply should treat an empty override as unset cost", () => {
+    const override: ModelOverride = {};
+    OverrideFields.byId("cost.input").apply(override, "0.5");
+    expect(override.cost).toEqual({ input: 0.5 });
   });
 });
 
-describe("overrideFieldValue", () => {
+describe("OverrideField.displayValue", () => {
+  const display = (id: string, override: ModelOverride): string =>
+    OverrideFields.byId(id).displayValue(new OverrideEntry("gpt-*", override));
+
   it("formats cost fields, defaulting to 0", () => {
-    expect(overrideFieldValue("cost.input", {})).toBe("0");
-    expect(overrideFieldValue("cost.input", { cost: { input: 0.2 } })).toBe(
-      "0.2",
-    );
-    expect(overrideFieldValue("cost.cacheWrite", {})).toBe("0");
+    expect(display("cost.input", {})).toBe("0");
+    expect(display("cost.input", { cost: { input: 0.2 } })).toBe("0.2");
+    expect(display("cost.cacheWrite", {})).toBe("0");
   });
 
   it("formats capabilities and reasoning labels", () => {
-    expect(overrideFieldValue("capabilities", {})).toBe("text");
-    expect(
-      overrideFieldValue("capabilities", { capabilities: ["text", "image"] }),
-    ).toBe("text | image");
-    expect(overrideFieldValue("reasoning", {})).toBe("true");
-    expect(overrideFieldValue("reasoning", { reasoning: false })).toBe("false");
+    expect(display("capabilities", {})).toBe("text");
+    expect(display("capabilities", { capabilities: ["text", "image"] })).toBe(
+      "text | image",
+    );
+    expect(display("reasoning", {})).toBe("true");
+    expect(display("reasoning", { reasoning: false })).toBe("false");
   });
 
   it("formats maxTokens/contextSize, defaulting to 0", () => {
-    expect(overrideFieldValue("maxTokens", {})).toBe("0");
-    expect(overrideFieldValue("maxTokens", { maxTokens: 4096 })).toBe("4096");
-    expect(overrideFieldValue("contextSize", { contextSize: 8192 })).toBe(
-      "8192",
-    );
+    expect(display("maxTokens", {})).toBe("0");
+    expect(display("maxTokens", { maxTokens: 4096 })).toBe("4096");
+    expect(display("contextSize", { contextSize: 8192 })).toBe("8192");
   });
 
-  it("returns an empty label for unknown fields", () => {
-    expect(overrideFieldValue("other", {})).toBe("");
+  it("returns the entry's pattern for the pattern field", () => {
+    expect(
+      OverrideFields.byId("pattern").displayValue(
+        new OverrideEntry("gpt-*", {}),
+      ),
+    ).toBe("gpt-*");
+  });
+
+  it("throws for unknown fields", () => {
+    expect(() => OverrideFields.byId("other")).toThrow(
+      "Unknown override field: other",
+    );
   });
 });