pi-llama-cpp 0.5.1 → 0.7.0

package/tests/legacyModel.test.ts

@@ -0,0 +1,112 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { Mode } from "../src/enums/mode";
+import { Status } from "../src/enums/status";
+import { DataProperty } from "../src/interfaces/endpoints/models";
+import { LegacyModel } from "../src/models/legacyModel";
+import { createMockServer, mockRpc } from "./mocks";
+
+beforeEach(() => {
+  mockRpc.mockReset();
+});
+
+const createModel = (extra: Partial<DataProperty> = {}): LegacyModel =>
+  new LegacyModel(
+    {
+      id: "test",
+      tags: [],
+      object: "model",
+      owned_by: "test",
+      created: Date.now(),
+      ...extra,
+    },
+    createMockServer(),
+  );
+
+describe("LegacyModel mode", () => {
+  it("should always return LEGACY mode", () => {
+    const model = createModel();
+    expect(model.mode).toBe(Mode.LEGACY);
+  });
+});
+
+describe("LegacyModel capabilities", () => {
+  it("should detect image capability when multimodal is in capabilities", async () => {
+    mockRpc.mockResolvedValueOnce({ modalities: { vision: true } });
+
+    const model = createModel();
+    const capabilities = await model.getCapabilities();
+
+    expect(capabilities).toEqual(["text", "image"]);
+  });
+
+  it("should detect text-only capability when multimodal is not in capabilities", async () => {
+    mockRpc.mockResolvedValueOnce({ modalities: { vision: false } });
+
+    const model = createModel();
+    const capabilities = await model.getCapabilities();
+
+    expect(capabilities).toEqual(["text"]);
+  });
+});
+
+describe("LegacyModel getStatus", () => {
+  it("should return LOADED when not sleeping", async () => {
+    mockRpc.mockResolvedValueOnce({ is_sleeping: false });
+
+    const model = createModel();
+    const status = await model.getStatus();
+
+    expect(status).toBe(Status.LOADED);
+    expect(mockRpc).toHaveBeenCalledWith(
+      `/props?model=${model.id}&autoload=false`,
+    );
+  });
+
+  it("should return SLEEPING when is_sleeping is true", async () => {
+    mockRpc.mockResolvedValueOnce({ is_sleeping: true });
+
+    const model = createModel();
+    const status = await model.getStatus();
+
+    expect(status).toBe(Status.SLEEPING);
+  });
+});
+
+describe("LegacyModel getContextSize", () => {
+  it("should use max_model_len when it is non-zero", async () => {
+    mockRpc.mockResolvedValueOnce({ n_ctx: 4096 });
+    mockRpc.mockResolvedValueOnce({
+      data: [{ max_model_len: 8192 }],
+    });
+
+    const model = createModel();
+    const ctxSize = await model.getContextSize();
+
+    expect(ctxSize).toBe(8192);
+    expect(mockRpc).toHaveBeenCalledWith("/v1/models");
+  });
+
+  it("should fall back to n_ctx when max_model_len is 0", async () => {
+    mockRpc.mockResolvedValueOnce({ n_ctx: 4096 });
+    mockRpc.mockResolvedValueOnce({
+      data: [{ max_model_len: 0 }],
+    });
+
+    const model = createModel();
+    const ctxSize = await model.getContextSize();
+
+    expect(ctxSize).toBe(4096);
+  });
+
+  it("should return DEFAULT_CTX when both values are missing/null", async () => {
+    mockRpc.mockResolvedValueOnce({});
+    mockRpc.mockResolvedValueOnce({
+      data: [{ max_model_len: null }],
+    });
+
+    const model = createModel();
+    const ctxSize = await model.getContextSize();
+
+    expect(ctxSize).toBe(128000);
+  });
+});

package/tests/mocks.ts

@@ -0,0 +1,100 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { vi } from "vitest";
+import { Mode } from "../src/enums/mode";
+import { ServerStatus } from "../src/enums/serverStatus";
+import { Status } from "../src/enums/status";
+import { BaseModel } from "../src/models/baseModel";
+import { Server } from "../src/server";
+
+/** Shared mock RPC — each test configures it */
+export const mockRpc = vi.fn();
+
+/** Default mock server that assumes everything works */
+export const createMockServer = (
+  overrides: Partial<Server & { apiKey?: string }> = {},
+): Server => {
+  const models: BaseModel[] = [];
+  const server: Partial<Server> = {
+    baseUrl: "http://127.0.0.1:8080",
+    models,
+    getApiKey: () => Promise.resolve(overrides.apiKey ?? ""),
+    fetchModels: () => mockRpc("/v1/models"),
+    fetchModelProps: (modelId: string) =>
+      mockRpc(`/props?model=${modelId}&autoload=false`),
+    fetchServerHealth: () => mockRpc("/health"),
+    fetchServerProps: () => mockRpc("/props?autoload=false"),
+    postRequest: (resource: "load" | "unload", model: string) =>
+      mockRpc(`/models/${resource}`, { model }),
+    isReady: async (timeout: number) => {
+      try {
+        const r = await mockRpc("/health");
+        return r.status === "ok"
+          ? ServerStatus.READY
+          : ServerStatus.UNREACHABLE;
+      } catch {
+        return ServerStatus.UNREACHABLE;
+      }
+    },
+    initialize: async () => {
+      const { data } = (await mockRpc("/v1/models")) as {
+        data: BaseModel[];
+      };
+      models.length = 0;
+      models.push(...(data ?? []));
+    },
+    ...overrides,
+  };
+  return server as Server;
+};
+
+/** Helper to create a mock BaseModel */
+export const createMockModel = (
+  name: string,
+  overrides: Partial<BaseModel> = {},
+): BaseModel =>
+  ({
+    name,
+    id: name,
+    mode: Mode.ROUTER,
+    serverUrl: "http://127.0.0.1:8080",
+    capabilities: ["text"] as ["text"],
+    getStatus: vi.fn().mockResolvedValue(Status.LOADED),
+    getContextSize: vi.fn().mockResolvedValue(4096),
+    getInfo: vi.fn().mockResolvedValue(`Model: ${name}\nID: ${name}`),
+    load: vi.fn().mockResolvedValue(undefined),
+    unload: vi.fn().mockResolvedValue(undefined),
+    toProviderConfig: vi.fn().mockResolvedValue({}),
+    getLabel: vi.fn().mockResolvedValue(name),
+    ...overrides,
+  }) as unknown as BaseModel;
+
+/** Create a mock extension context */
+export const createMockCtx = (
+  selectFn: (prompt: string, options: string[]) => string | null,
+) => ({
+  cwd: "/tmp/test",
+  ui: {
+    select: vi.fn(selectFn),
+    notify: vi.fn(),
+    theme: {
+      fg: (color: string, text: string) => text,
+    },
+  },
+  modelRegistry: {
+    find: vi.fn().mockReturnValue({ id: "test-model-id" }),
+  },
+});
+
+/** Create a mock Pi instance */
+export const createMockPi = () => ({
+  setModel: vi.fn(),
+  registerProvider: vi.fn(),
+});
+
+/** Create a mock Pi context for EventManager */
+export const createMockPiContext = (notifyFn: ReturnType<typeof vi.fn>) =>
+  ({
+    ui: {
+      notify: notifyFn,
+    },
+  }) as any as ExtensionContext;

package/tests/resolver.test.ts

@@ -2,156 +2,193 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import {
   API_KEY_PLACEHOLDER,
   DEFAULT_LLAMA_SERVER_URL,
-  PROVIDER_ID,
 } from "../src/constants";
 
+// Hoisted mock instances — survives vi.resetModules()
+const mockAuthStorage = vi.hoisted(() => ({
+  reload: vi.fn(),
+  getApiKey: vi.fn(),
+}));
+
+const mockSettingsManager = vi.hoisted(() => ({
+  getProjectSettings: vi.fn(),
+  getGlobalSettings: vi.fn(),
+}));
+
+// Mock getAgentDir, AuthStorage, and SettingsManager before importing resolver
+vi.mock("@earendil-works/pi-coding-agent", () => ({
+  getAgentDir: vi.fn().mockReturnValue("/fake/agent/dir"),
+  AuthStorage: {
+    create: vi.fn().mockReturnValue(mockAuthStorage),
+  },
+  SettingsManager: {
+    create: vi.fn().mockReturnValue(mockSettingsManager),
+  },
+}));
+
+vi.mock("node:fs/promises", () => ({
+  readFile: vi.fn(),
+}));
+
+// Import mocked modules
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { readFile } from "node:fs/promises";
+import { ConfigResolver } from "../src/resolver";
+
 describe("URL resolution fallback chain", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    vi.resetModules();
-  });
+  const mockReadFile = vi.mocked(readFile);
+  const mockGetAgentDir = vi.mocked(getAgentDir);
+  const mockGetProjectSettings = vi.mocked(
+    mockSettingsManager.getProjectSettings,
+  );
+  const mockGetGlobalSettings = vi.mocked(
+    mockSettingsManager.getGlobalSettings,
+  );
 
   afterEach(() => {
     delete process.env.LLAMA_SERVER_URL;
+    vi.resetModules();
   });
 
-  it("should return default URL when no config is found", async () => {
-    vi.doMock("node:fs/promises", () => ({
-      access: vi.fn().mockRejectedValue(new Error("ENOENT")),
-      constants: { F_OK: 0 },
-      readFile: vi.fn().mockResolvedValue(""),
-    }));
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockGetAgentDir.mockReturnValue("/fake/agent/dir");
+    // Default: no settings found
+    mockGetProjectSettings.mockReturnValue({});
+    mockGetGlobalSettings.mockReturnValue({});
+  });
 
-    const { resolveUrl } = await import("../src/tools/resolver");
-    const result = await resolveUrl("/tmp/test-project");
+  it("should return default URL when no config is found", async () => {
+    const resolver = new ConfigResolver();
+    const result = await resolver.resolveUrls();
 
-    expect(result).toBe(DEFAULT_LLAMA_SERVER_URL);
+    expect(result).toEqual([DEFAULT_LLAMA_SERVER_URL]);
   });
 
   it("should prioritize project config over env variable", async () => {
-    vi.doMock("node:fs/promises", () => ({
-      access: vi.fn().mockImplementation(async (path: string) => {
-        if (path.includes("llama-server.json")) return undefined;
-        throw new Error("ENOENT");
-      }),
-      constants: { F_OK: 0 },
-      readFile: vi
-        .fn()
-        .mockResolvedValue(JSON.stringify({ url: "http://localhost:9999" })),
-    }));
-
+    mockGetProjectSettings.mockReturnValue({
+      llamaServerUrl: "http://localhost:9999",
+    });
     process.env.LLAMA_SERVER_URL = "http://env-url:8080";
 
-    const { resolveUrl } = await import("../src/tools/resolver");
-    const result = await resolveUrl("/tmp/test-project");
+    const resolver = new ConfigResolver();
+    const result = await resolver.resolveUrls();
 
-    expect(result).toBe("http://localhost:9999");
+    expect(result).toEqual(["http://localhost:9999"]);
   });
 
   it("should use env variable when no project config exists", async () => {
-    vi.doMock("node:fs/promises", () => ({
-      access: vi.fn().mockRejectedValue(new Error("ENOENT")),
-      constants: { F_OK: 0 },
-      readFile: vi.fn().mockResolvedValue(""),
-    }));
-
+    mockGetProjectSettings.mockReturnValue({});
     process.env.LLAMA_SERVER_URL = "http://env-url:8080";
 
-    const { resolveUrl } = await import("../src/tools/resolver");
-    const result = await resolveUrl("/tmp/test-project");
+    const resolver = new ConfigResolver();
+    const result = await resolver.resolveUrls();
 
-    expect(result).toBe("http://env-url:8080");
+    expect(result).toEqual(["http://env-url:8080"]);
   });
 
   it("should use global settings when no project config or env exists", async () => {
-    vi.doMock("node:fs/promises", () => ({
-      access: vi.fn().mockImplementation(async (path: string) => {
-        if (path.includes("settings.json")) return undefined;
-        throw new Error("ENOENT");
-      }),
-      constants: { F_OK: 0 },
-      readFile: vi
-        .fn()
-        .mockResolvedValue(
-          JSON.stringify({ llamaServerUrl: "http://global:8080" }),
-        ),
-    }));
-
-    const { resolveUrl } = await import("../src/tools/resolver");
-    const result = await resolveUrl("/tmp/test-project");
-
-    expect(result).toBe("http://global:8080");
+    mockGetProjectSettings.mockReturnValue({});
+    mockGetGlobalSettings.mockReturnValue({
+      llamaServerUrl: "http://global:8080",
+    });
+
+    const resolver = new ConfigResolver();
+    const result = await resolver.resolveUrls();
+
+    expect(result).toEqual(["http://global:8080"]);
   });
 
   it("should strip trailing slashes from resolved URL", async () => {
-    vi.doMock("node:fs/promises", () => ({
-      access: vi.fn().mockImplementation(async (path: string) => {
-        if (path.includes("llama-server.json")) return undefined;
-        throw new Error("ENOENT");
-      }),
-      constants: { F_OK: 0 },
-      readFile: vi
-        .fn()
-        .mockResolvedValue(JSON.stringify({ url: "http://localhost:8080/" })),
-    }));
-
-    const { resolveUrl } = await import("../src/tools/resolver");
-    const result = await resolveUrl("/tmp/test-project");
-
-    expect(result).toBe("http://localhost:8080");
+    mockGetProjectSettings.mockReturnValue({
+      llamaServerUrl: "http://localhost:8080/",
+    });
+
+    const resolver = new ConfigResolver();
+    const result = await resolver.resolveUrls();
+
+    expect(result).toEqual(["http://localhost:8080"]);
+  });
+
+  it("should cache the resolved URL on subsequent calls", async () => {
+    mockGetProjectSettings.mockReturnValue({
+      llamaServerUrl: "http://first:8080",
+    });
+
+    const resolver = new ConfigResolver();
+    const result1 = await resolver.resolveUrls();
+    const result2 = await resolver.resolveUrls();
+
+    expect(result1).toEqual(["http://first:8080"]);
+    expect(result2).toEqual(["http://first:8080"]);
+  });
+
+  it("should handle multiple URLs separated by semicolons", async () => {
+    mockGetProjectSettings.mockReturnValue({
+      llamaServerUrl: "http://first:8080;http://second:9090/",
+    });
+
+    const resolver = new ConfigResolver();
+    const result = await resolver.resolveUrls();
+
+    expect(result).toEqual(["http://first:8080", "http://second:9090"]);
   });
 });
 
 describe("API key resolution", () => {
+  const mockGetAgentDir = vi.mocked(getAgentDir);
+
+  afterEach(() => {
+    vi.resetModules();
+  });
+
   beforeEach(() => {
     vi.clearAllMocks();
-    vi.resetModules();
+    mockGetAgentDir.mockReturnValue("/fake/agent/dir");
+    mockAuthStorage.reload.mockReturnValue(undefined);
+    mockAuthStorage.getApiKey.mockResolvedValue(undefined);
   });
 
   it("should return placeholder when auth file does not exist", async () => {
-    vi.doMock("node:fs/promises", () => ({
-      access: vi.fn().mockRejectedValue(new Error("ENOENT")),
-      constants: { F_OK: 0 },
-      readFile: vi.fn().mockResolvedValue(""),
-    }));
+    mockAuthStorage.getApiKey.mockResolvedValue(undefined);
 
-    const { resolveApiKey } = await import("../src/tools/resolver");
-    const result = await resolveApiKey();
+    const resolver = new ConfigResolver();
+    const result = await resolver.resolveApiKey(
+      "llama-server=http://127.0.0.1:8080",
+    );
 
-    expect(result).toBe(API_KEY_PLACEHOLDER);
+    expect(result).toEqual(API_KEY_PLACEHOLDER);
   });
 
   it("should return placeholder when provider key is missing", async () => {
-    vi.doMock("node:fs/promises", () => ({
-      access: vi.fn().mockResolvedValue(undefined),
-      constants: { F_OK: 0 },
-      readFile: vi
-        .fn()
-        .mockResolvedValue(
-          JSON.stringify({ "other-provider": { key: "other-key" } }),
-        ),
-    }));
-
-    const { resolveApiKey } = await import("../src/tools/resolver");
-    const result = await resolveApiKey();
-
-    expect(result).toBe(API_KEY_PLACEHOLDER);
+    mockAuthStorage.getApiKey.mockResolvedValue(undefined);
+
+    const resolver = new ConfigResolver();
+    const result = await resolver.resolveApiKey(
+      "llama-server=http://127.0.0.1:8080",
+    );
+
+    expect(result).toEqual(API_KEY_PLACEHOLDER);
   });
 
   it("should return the provider key when present", async () => {
-    vi.doMock("node:fs/promises", () => ({
-      access: vi.fn().mockResolvedValue(undefined),
-      constants: { F_OK: 0 },
-      readFile: vi
-        .fn()
-        .mockResolvedValue(
-          JSON.stringify({ [PROVIDER_ID]: { key: "test-api-key" } }),
-        ),
-    }));
-
-    const { resolveApiKey } = await import("../src/tools/resolver");
-    const result = await resolveApiKey();
-
-    expect(result).toBe("test-api-key");
+    mockAuthStorage.getApiKey.mockResolvedValue("test-api-key");
+
+    const resolver = new ConfigResolver();
+    const result = await resolver.resolveApiKey(
+      "llama-server=http://127.0.0.1:8080",
+    );
+
+    expect(result).toEqual("test-api-key");
+  });
+
+  it("should call reload before each getApiKey", async () => {
+    mockAuthStorage.getApiKey.mockResolvedValue("cached-key");
+
+    const resolver = new ConfigResolver();
+    await resolver.resolveApiKey("llama-server=http://127.0.0.1:8080");
+    await resolver.resolveApiKey("llama-server=http://127.0.0.1:8080");
+
+    expect(mockAuthStorage.reload).toHaveBeenCalledTimes(2);
   });
 });