pi-llama-cpp 0.10.0 → 0.12.0

package/tests/commandManager.test.ts

@@ -1,16 +1,28 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { initTheme } from "@earendil-works/pi-coding-agent";
+import type { KeybindingsManager, TUI } from "@earendil-works/pi-tui";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import { Action } from "../src/enums/action";
-import { CommandManager } from "../src/managers/command";
+import {
+  applySettingChange,
+  buildSettingsItems,
+  CommandManager,
+  formatMs,
+} from "../src/managers/command";
 import { ServerManager } from "../src/managers/server";
+import type { LlamaSettingsManager } from "../src/managers/settings";
+import { ServerSettingsList } from "../src/ui/serverSettingsList";
 import {
   createMockCtx,
   createMockModel,
   createMockPi,
   createMockServer,
+  makeSettingsStub,
   mockRpc,
 } from "./mocks";
 
 beforeEach(() => {
+  initTheme();
   vi.clearAllMocks();
   mockRpc.mockResolvedValue({ data: [] });
 });
@@ -18,19 +30,27 @@ beforeEach(() => {
 describe("CommandManager", () => {
   let serverManager: ServerManager;
   let commandManager: CommandManager;
+  let settingsStub: LlamaSettingsManager;
   let mockPi: ReturnType<typeof createMockPi>;
 
   beforeEach(() => {
     mockPi = createMockPi();
-    serverManager = new ServerManager([]);
-    commandManager = new CommandManager(serverManager);
+    settingsStub = makeSettingsStub();
+    serverManager = new ServerManager(settingsStub);
+    commandManager = new CommandManager(serverManager, settingsStub);
   });
 
   describe("getArgumentCompletions", () => {
     it("should provide completions for /models", () => {
       const completions = commandManager.getArgumentCompletions("");
-      expect(completions).toHaveLength(2);
-      expect(completions?.map((c) => c.value)).toEqual(["info", "unload"]);
+      expect(completions).toHaveLength(5);
+      expect(completions?.map((c) => c.value)).toEqual([
+        "info",
+        "unload",
+        "settings",
+        "servers",
+        "overrides",
+      ]);
     });
 
     it("should filter completions by prefix", () => {
@@ -43,6 +63,11 @@ describe("CommandManager", () => {
       const completions = commandManager.getArgumentCompletions("zzz");
       expect(completions).toBeNull();
     });
+
+    it("should provide the server/settings completions by prefix", () => {
+      const completions = commandManager.getArgumentCompletions("s");
+      expect(completions?.map((c) => c.value)).toEqual(["settings", "servers"]);
+    });
   });
 
   describe("handleCommand", () => {
@@ -53,8 +78,11 @@ describe("CommandManager", () => {
         baseUrl: "http://127.0.0.1:8080",
         models: [model1, model2],
       });
-      serverManager = new ServerManager([server] as any);
-      commandManager = new CommandManager(serverManager);
+      const unloadSettings = makeSettingsStub({
+        resolveServers: vi.fn(async () => [server]),
+      });
+      serverManager = new ServerManager(unloadSettings);
+      commandManager = new CommandManager(serverManager, unloadSettings);
 
       const ctx = {
         ui: {
@@ -80,8 +108,11 @@ describe("CommandManager", () => {
         baseUrl: "http://127.0.0.1:8080",
         models: [model1, model2],
       });
-      serverManager = new ServerManager([server] as any);
-      commandManager = new CommandManager(serverManager);
+      const infoSettings = makeSettingsStub({
+        resolveServers: vi.fn(async () => [server]),
+      });
+      serverManager = new ServerManager(infoSettings);
+      commandManager = new CommandManager(serverManager, infoSettings);
 
       const ctx = {
         ui: {
@@ -97,6 +128,272 @@ describe("CommandManager", () => {
     });
   });
 
+  describe("settings menu helpers", () => {
+    it("should format milliseconds compactly", () => {
+      expect(formatMs(500)).toBe("500ms");
+      expect(formatMs(60000)).toBe("60s");
+      expect(formatMs(1500)).toBe("1500ms");
+    });
+
+    it("should build one item per editable scalar field", async () => {
+      const items = await buildSettingsItems(settingsStub);
+      expect(items.map((i) => i.id)).toEqual([
+        "reactToModelSelect",
+        "autoloadOnMessage",
+        "sortBy",
+        "pollingTimeout",
+        "serverTimeout",
+      ]);
+      // Booleans are displayed as on/off
+      expect(items[0].values).toEqual(["on", "off"]);
+      // Timeouts cycle through formatted presets
+      expect(items[3].values).toEqual(["15s", "30s", "60s", "120s", "300s"]);
+      expect(items[4].values).toEqual(["500ms", "1s", "2s", "5s", "10s"]);
+    });
+
+    it("should map changes to the right key and type", async () => {
+      const settingsStub = makeSettingsStub();
+
+      await applySettingChange("reactToModelSelect", "on", settingsStub);
+      expect(settingsStub.setLlamaSetting).toHaveBeenCalledWith(
+        "reactToModelSelect",
+        true,
+      );
+
+      await applySettingChange("autoloadOnMessage", "off", settingsStub);
+      expect(settingsStub.setLlamaSetting).toHaveBeenCalledWith(
+        "autoloadOnMessage",
+        false,
+      );
+
+      await applySettingChange("sortBy", "desc-name", settingsStub);
+      expect(settingsStub.setLlamaSetting).toHaveBeenCalledWith(
+        "sortBy",
+        "desc-name",
+      );
+
+      await applySettingChange("pollingTimeout", "120s", settingsStub);
+      expect(settingsStub.setLlamaSetting).toHaveBeenCalledWith(
+        "pollingTimeout",
+        120000,
+      );
+
+      await applySettingChange("serverTimeout", "500ms", settingsStub);
+      expect(settingsStub.setLlamaSetting).toHaveBeenCalledWith(
+        "serverTimeout",
+        500,
+      );
+    });
+  });
+
+  describe("/models settings menu", () => {
+    it("should open the settings menu without touching servers", async () => {
+      const updateSpy = vi
+        .spyOn(serverManager, "update")
+        .mockResolvedValue(undefined);
+      const ctx = createMockCtx(() => null);
+
+      await commandManager.handleCommand("settings", ctx as any, mockPi as any);
+
+      expect(updateSpy).not.toHaveBeenCalled();
+      expect(ctx.ui.notify).not.toHaveBeenCalled();
+      expect(ctx.ui.custom).toHaveBeenCalledTimes(1);
+    });
+
+    it("should notify instead of opening the menu outside the TUI", async () => {
+      const ctx = { ...createMockCtx(() => null), mode: "rpc" } as any;
+
+      await commandManager.handleCommand("settings", ctx, mockPi as any);
+
+      expect(ctx.ui.custom).not.toHaveBeenCalled();
+      expect(ctx.ui.notify).toHaveBeenCalledWith(
+        "/models settings requires an interactive session (TUI)",
+        "warning",
+      );
+    });
+  });
+
+  describe("/models servers editor", () => {
+    const ESC = "\x1b";
+    const ENTER = "\r";
+
+    const createMockKeybindings = (): KeybindingsManager =>
+      ({
+        matches: vi.fn(
+          (data: string, name: string) =>
+            (data === ENTER && name === "tui.select.confirm") ||
+            (data === ESC && name === "tui.select.cancel") ||
+            (data === "\x1b[A" && name === "tui.select.up") ||
+            (data === "\x1b[B" && name === "tui.select.down"),
+        ),
+      }) as unknown as KeybindingsManager;
+
+    const createMockTheme = (): Theme =>
+      ({
+        fg: (_color: string, text: string) => text,
+        bold: (text: string) => text,
+      }) as unknown as Theme;
+
+    it("should open the editor without touching servers", async () => {
+      const updateSpy = vi
+        .spyOn(serverManager, "update")
+        .mockResolvedValue(undefined);
+      const ctx = createMockCtx(() => null);
+
+      await commandManager.handleCommand("servers", ctx as any, mockPi as any);
+
+      expect(updateSpy).not.toHaveBeenCalled();
+      expect(ctx.ui.custom).toHaveBeenCalledTimes(1);
+    });
+
+    it("should notify instead of opening the editor outside the TUI", async () => {
+      const ctx = { ...createMockCtx(() => null), mode: "rpc" } as any;
+
+      await commandManager.handleCommand("servers", ctx, mockPi as any);
+
+      expect(ctx.ui.custom).not.toHaveBeenCalled();
+      expect(ctx.ui.notify).toHaveBeenCalledWith(
+        "/models servers requires an interactive session (TUI)",
+        "warning",
+      );
+    });
+
+    it("should wire the editor to the merged servers and the write path", async () => {
+      const editorSettings = makeSettingsStub({
+        getLlamaServers: vi.fn(async () => [{ url: "http://seed:1" }]),
+      });
+      commandManager = new CommandManager(serverManager, editorSettings);
+      const ctx = createMockCtx(() => null);
+
+      await commandManager.handleCommand("servers", ctx as any, mockPi as any);
+
+      // Invoke the factory captured from ctx.ui.custom
+      const factory = vi.mocked(ctx.ui.custom).mock.calls[0][0] as (
+        tui: TUI,
+        theme: Theme,
+        kb: KeybindingsManager,
+        done: (result: undefined) => void,
+      ) => ServerSettingsList;
+      const done = vi.fn();
+      const editor = factory(
+        { requestRender: vi.fn() } as unknown as TUI,
+        createMockTheme(),
+        {
+          matches: vi.fn(
+            (data: string, name: string) =>
+              (data === ENTER && name === "tui.select.confirm") ||
+              (data === ESC && name === "tui.select.cancel"),
+          ),
+        } as unknown as KeybindingsManager,
+        done,
+      );
+
+      expect(editor).toBeInstanceOf(ServerSettingsList);
+      // Seeded with the merged snapshot
+      expect(editor.render(80).join("\n")).toContain("http://seed:1");
+
+      // Add a server through the wizard (URL → ID → name) →
+      // setLlamaSetting("servers", …) persists only after the final step
+      editor.handleInput("a");
+      expect(editor.render(80).join("\n")).toContain("Add server · 1/3");
+      for (const ch of "http://new:2") editor.handleInput(ch);
+      editor.handleInput(ENTER);
+      expect(editor.render(80).join("\n")).toContain("Add server · 2/3");
+      editor.handleInput(ENTER); // skip optional ID
+      expect(editor.render(80).join("\n")).toContain("Add server · 3/3");
+      editor.handleInput(ENTER); // skip optional name → persist
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      expect(editorSettings.setLlamaSetting).toHaveBeenCalledWith("servers", [
+        { url: "http://seed:1" },
+        { url: "http://new:2" },
+      ]);
+
+      // Esc closes the editor
+      editor.handleInput(ESC);
+      expect(done).toHaveBeenCalledTimes(1);
+    });
+
+    it("should persist nothing when the add wizard is cancelled", async () => {
+      const editorSettings = makeSettingsStub({
+        getLlamaServers: vi.fn(async () => [{ url: "http://seed:1" }]),
+      });
+      commandManager = new CommandManager(serverManager, editorSettings);
+      const ctx = createMockCtx(() => null);
+
+      await commandManager.handleCommand("servers", ctx as any, mockPi as any);
+
+      const factory = vi.mocked(ctx.ui.custom).mock.calls[0][0] as (
+        tui: TUI,
+        theme: Theme,
+        kb: KeybindingsManager,
+        done: (result: undefined) => void,
+      ) => ServerSettingsList;
+      const editor = factory(
+        { requestRender: vi.fn() } as unknown as TUI,
+        createMockTheme(),
+        createMockKeybindings(),
+        vi.fn(),
+      );
+
+      // Walk to wizard step 2, then abort — nothing must be persisted
+      editor.handleInput("a");
+      for (const ch of "http://new:2") editor.handleInput(ch);
+      editor.handleInput(ENTER);
+      editor.handleInput(ESC);
+      await new Promise((resolve) => setTimeout(resolve, 0));
+
+      expect(editorSettings.setLlamaSetting).not.toHaveBeenCalled();
+      // Back to the list view
+      expect(editor.render(80).join("\n")).toContain("http://seed:1");
+    });
+
+    it("should delete the selected server after confirming", async () => {
+      const editorSettings = makeSettingsStub({
+        getLlamaServers: vi.fn(async () => [
+          { url: "http://seed:1" },
+          { url: "http://doomed:2" },
+        ]),
+      });
+      commandManager = new CommandManager(serverManager, editorSettings);
+      const ctx = createMockCtx(() => null);
+
+      await commandManager.handleCommand("servers", ctx as any, mockPi as any);
+
+      const factory = vi.mocked(ctx.ui.custom).mock.calls[0][0] as (
+        tui: TUI,
+        theme: Theme,
+        kb: KeybindingsManager,
+        done: (result: undefined) => void,
+      ) => ServerSettingsList;
+      const editor = factory(
+        { requestRender: vi.fn() } as unknown as TUI,
+        createMockTheme(),
+        createMockKeybindings(),
+        vi.fn(),
+      );
+
+      // Move to the second row and open the confirm dialog
+      editor.handleInput("\x1b[B");
+      editor.handleInput("d");
+      expect(editor.render(80).join("\n")).toContain(
+        'Delete "http://doomed:2"?',
+      );
+
+      // Esc keeps the server
+      editor.handleInput(ESC);
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      expect(editorSettings.setLlamaSetting).not.toHaveBeenCalled();
+
+      // Re-open and confirm the default "Delete" selection
+      editor.handleInput("d");
+      editor.handleInput(ENTER);
+      await new Promise((resolve) => setTimeout(resolve, 0));
+      expect(editorSettings.setLlamaSetting).toHaveBeenCalledWith("servers", [
+        { url: "http://seed:1" },
+      ]);
+    });
+  });
+
   describe("/models interactive menu", () => {
     const CHOICE = "model-a   [Server: http://127.0.0.1:8080]";
 
@@ -113,10 +410,15 @@ describe("CommandManager", () => {
           models: [model],
         }),
       );
-      const serverManager = new ServerManager(servers as any);
+      const settingsStub = makeSettingsStub({
+        resolveServers: vi.fn(async () => servers),
+      });
+      const serverManager = new ServerManager(settingsStub);
       return {
-        commandManager: new CommandManager(serverManager),
+        commandManager: new CommandManager(serverManager, settingsStub),
         serverManager,
+        settingsStub,
+        servers,
         mockPi,
       };
     };
@@ -198,5 +500,38 @@ describe("CommandManager", () => {
       expect(ctx.ui.select).toHaveBeenCalledTimes(3);
       expect(ctx.ui.notify).not.toHaveBeenCalled();
     });
+
+    it("should pick up servers added via the editor on the next /models scan", async () => {
+      const { commandManager, settingsStub, servers } = createCommandManager([
+        createMockModel("model-a"),
+      ]);
+
+      const ctx = createMockCtx(() => null);
+      await commandManager.handleCommand("", ctx as any, mockPi as any);
+
+      // First scan: only model-a is offered
+      let choices = vi.mocked(ctx.ui.select).mock.calls[0][1] as string[];
+      expect(choices).toHaveLength(1);
+      expect(choices[0]).toContain("model-a");
+
+      // Editor persist → settings change → resolveServers now returns both
+      const modelB = createMockModel("model-b", {
+        serverUrl: "http://127.0.0.1:8081",
+      });
+      const serverB = createMockServer({
+        baseUrl: "http://127.0.0.1:8081",
+        models: [modelB],
+      });
+      vi.mocked(settingsStub.resolveServers).mockResolvedValue([
+        ...servers,
+        serverB,
+      ]);
+
+      await commandManager.handleCommand("", ctx as any, mockPi as any);
+
+      choices = vi.mocked(ctx.ui.select).mock.calls[1][1] as string[];
+      expect(choices).toHaveLength(2);
+      expect(choices[1]).toContain("model-b");
+    });
   });
 });

package/tests/dialog.test.ts

@@ -0,0 +1,186 @@
+import { initTheme, type Theme } from "@earendil-works/pi-coding-agent";
+import {
+  getKeybindings,
+  type KeybindingsManager,
+  type TUI,
+} from "@earendil-works/pi-tui";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { ConfirmDialog, InputDialog } from "../src/ui/dialog";
+import { ServerSettingsList } from "../src/ui/serverSettingsList";
+
+beforeEach(() => {
+  initTheme();
+  vi.clearAllMocks();
+});
+
+const ESC = "\x1b";
+const ENTER = "\r";
+
+const createMockTheme = (): Theme =>
+  ({
+    fg: (_color: string, text: string) => text,
+    bold: (text: string) => text,
+  }) as unknown as Theme;
+
+const createMockTui = (): TUI => ({ requestRender: vi.fn() }) as unknown as TUI;
+
+const createKeybindings = (): KeybindingsManager => getKeybindings();
+
+describe("InputDialog", () => {
+  const build = (
+    overrides: Partial<ConstructorParameters<typeof InputDialog>[0]> = {},
+  ) => {
+    const onSubmit = vi.fn();
+    const onCancel = vi.fn();
+    const dialog = new InputDialog({
+      theme: createMockTheme(),
+      tui: createMockTui(),
+      title: "Dialog title",
+      message: "Server URL",
+      placeholder: "http://127.0.0.1:8080",
+      validate: (raw) => (raw.startsWith("http") ? raw : null),
+      onSubmit,
+      onCancel,
+      ...overrides,
+    });
+    return { dialog, onSubmit, onCancel };
+  };
+
+  it("renders the framed title, message, placeholder and key hints", () => {
+    const { dialog } = build();
+    const rendered = dialog.render(60).join("\n");
+    expect(rendered).toContain("Dialog title");
+    expect(rendered).toContain("Server URL");
+    expect(rendered).toContain("e.g., http://127.0.0.1:8080");
+  });
+
+  it("submits the validated value on Enter", () => {
+    const { dialog, onSubmit, onCancel } = build({
+      initialValue: "http://x:1",
+    });
+    dialog.handleInput(ENTER);
+    expect(onSubmit).toHaveBeenCalledWith("http://x:1");
+    expect(onCancel).not.toHaveBeenCalled();
+  });
+
+  it("keeps the dialog open with an error on invalid input", () => {
+    const { dialog, onSubmit, onCancel } = build();
+    for (const ch of "no-scheme") dialog.handleInput(ch);
+    dialog.handleInput(ENTER);
+    expect(onSubmit).not.toHaveBeenCalled();
+    expect(dialog.render(60).join("\n")).toContain('Invalid value "no-scheme"');
+
+    // Esc still cancels after an error
+    dialog.handleInput(ESC);
+    expect(onCancel).toHaveBeenCalledTimes(1);
+  });
+
+  it("cancels on Esc without submitting", () => {
+    const { dialog, onSubmit, onCancel } = build({
+      initialValue: "http://x:1",
+    });
+    dialog.handleInput(ESC);
+    expect(onCancel).toHaveBeenCalledTimes(1);
+    expect(onSubmit).not.toHaveBeenCalled();
+  });
+});
+
+describe("ConfirmDialog", () => {
+  const build = () => {
+    const onConfirm = vi.fn();
+    const onCancel = vi.fn();
+    const dialog = new ConfirmDialog({
+      theme: createMockTheme(),
+      tui: createMockTui(),
+      title: "Delete server",
+      message: 'Delete "http://x:1"?',
+      onConfirm,
+      onCancel,
+    });
+    return { dialog, onConfirm, onCancel };
+  };
+
+  it("renders the framed message and both options", () => {
+    const { dialog } = build();
+    const rendered = dialog.render(60).join("\n");
+    expect(rendered).toContain("Delete server");
+    expect(rendered).toContain('Delete "http://x:1"?');
+    expect(rendered).toContain("Delete");
+    expect(rendered).toContain("Cancel");
+  });
+
+  it("confirms with Enter on the default selection", () => {
+    const { dialog, onConfirm, onCancel } = build();
+    dialog.handleInput(ENTER);
+    expect(onConfirm).toHaveBeenCalledTimes(1);
+    expect(onCancel).not.toHaveBeenCalled();
+  });
+
+  it("cancels on Esc", () => {
+    const { dialog, onConfirm, onCancel } = build();
+    dialog.handleInput(ESC);
+    expect(onCancel).toHaveBeenCalledTimes(1);
+    expect(onConfirm).not.toHaveBeenCalled();
+  });
+});
+
+describe("ServerSettingsList add wizard", () => {
+  const buildEditor = (servers: { url: string; id?: string }[] = []) => {
+    const persist = vi.fn().mockResolvedValue(undefined);
+    const done = vi.fn();
+    const onError = vi.fn();
+    const editor = new ServerSettingsList({
+      tui: createMockTui(),
+      theme: createMockTheme(),
+      keybindings: createKeybindings(),
+      servers: servers as never[],
+      persist,
+      done,
+      onError,
+    });
+    return { editor, persist, done, onError };
+  };
+
+  it("persists only the URL when the optional steps are skipped", async () => {
+    const { editor, persist } = buildEditor();
+
+    editor.handleInput("a");
+    for (const ch of "http://x:1") editor.handleInput(ch);
+    editor.handleInput(ENTER); // URL → ID
+    editor.handleInput(ENTER); // skip ID → name
+    editor.handleInput(ENTER); // skip name → persist
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(persist).toHaveBeenCalledWith([{ url: "http://x:1" }]);
+  });
+
+  it("persists the URL and ID when the ID step is filled", async () => {
+    const { editor, persist } = buildEditor();
+
+    editor.handleInput("a");
+    for (const ch of "http://x:1") editor.handleInput(ch);
+    editor.handleInput(ENTER);
+    for (const ch of "my-id") editor.handleInput(ch);
+    editor.handleInput(ENTER); // ID → name
+    editor.handleInput(ENTER); // skip name → persist
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(persist).toHaveBeenCalledWith([{ url: "http://x:1", id: "my-id" }]);
+  });
+
+  it("rejects an invalid URL at step 1 and aborts cleanly on Esc", async () => {
+    const { editor, persist } = buildEditor();
+
+    editor.handleInput("a");
+    for (const ch of "not-a-url") editor.handleInput(ch);
+    editor.handleInput(ENTER);
+    expect(persist).not.toHaveBeenCalled();
+    expect(editor.render(80).join("\n")).toContain('Invalid value "not-a-url"');
+
+    editor.handleInput(ESC);
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(persist).not.toHaveBeenCalled();
+    // Back at the (empty) list view
+    expect(editor.render(80).join("\n")).toContain("(a) add server");
+  });
+});