pi-llama-cpp 0.5.0 → 0.6.0

package/src/manager.ts

@@ -1,93 +0,0 @@
-import type {
-  ExtensionAPI,
-  ExtensionCommandContext,
-  ProviderModelConfig,
-} from "@earendil-works/pi-coding-agent";
-import { modelsCommand, notFoundCommand } from "./commands/models";
-import {
-  DEFAULT_LLAMA_SERVER_URL,
-  PROVIDER_ID,
-  PROVIDER_NAME,
-} from "./constants";
-import { BaseModel } from "./models/baseModel";
-import { resolveApiKey, resolveUrl } from "./tools/resolver";
-import { isServerReady, listModels } from "./tools/retriever";
-
-export class CommandManager {
-  private baseUrl: string = DEFAULT_LLAMA_SERVER_URL;
-  private serverModels: BaseModel[] = [];
-
-  constructor(private readonly pi: ExtensionAPI) {}
-
-  /**
-   * Sets up the initial state of the provider
-   */
-  async initialize() {
-    if (await isServerReady()) {
-      await this.update();
-    } else {
-      await this.register([]);
-    }
-  }
-
-  /**
-   * Ensures the models are up-to-date with the server
-   */
-  async update() {
-    this.baseUrl = `${await resolveUrl(process.cwd())}`;
-
-    this.serverModels = await listModels();
-    const modelConfigs = await Promise.all(
-      this.serverModels.map((m) => m.toProviderConfig()),
-    );
-
-    await this.register(modelConfigs);
-  }
-
-  /**
-   * Registers the provider in Pi with the given configurations
-   * Note: Registrations overload previous provider
-   *
-   * @param models Provider configurations for the models
-   */
-  async register(models: ProviderModelConfig[]) {
-    this.pi.registerProvider(PROVIDER_ID, {
-      name: PROVIDER_NAME,
-      baseUrl: this.baseUrl,
-      api: "openai-completions",
-      apiKey: await resolveApiKey(),
-      models,
-    });
-  }
-
-  /**
-   * Dispatches the /models command
-   *
-   * @param args Arguments passed to the command
-   * @param ctx The context used by Pi
-   * @param pi The Pi extension
-   */
-  async run(args: string, ctx: ExtensionCommandContext) {
-    if (!(await isServerReady())) {
-      return await notFoundCommand(ctx);
-    }
-
-    // Command: `/models info`
-    if (args === "info") {
-      const info = await Promise.all(this.serverModels.map((m) => m.getInfo()));
-      const message = ctx.ui.theme.fg("accent", info.join("\n"));
-      ctx.ui.notify(message, "info");
-      return;
-    }
-
-    // Command: `/models unload`
-    if (args === "unload") {
-      await Promise.all(this.serverModels.map((m) => m.unload()));
-      ctx.ui.notify(`Unloaded all ${PROVIDER_NAME} models`, "info");
-      return;
-    }
-
-    // Command: `/models` (interactive menu)
-    return await modelsCommand(ctx, this.pi, this.serverModels);
-  }
-}

package/src/tools/resolver.ts

@@ -1,141 +0,0 @@
-import { access, constants, readFile } from "node:fs/promises";
-import { join } from "node:path";
-import {
-  API_KEY_PLACEHOLDER,
-  DEFAULT_LLAMA_SERVER_URL,
-  PROVIDER_ID,
-} from "../constants";
-import { AuthFile } from "../interfaces/auth";
-
-// The URL is detected once, to reuse forever
-let resolvedUrl: string | undefined;
-
-/**
- * Detects if a particular file is present
- * @param filePath The path
- * @returns True if exists
- */
-const fileExists = async (filePath: string): Promise<boolean> => {
-  try {
-    await access(filePath, constants.F_OK);
-    return true;
-  } catch (error) {
-    return false;
-  }
-};
-
-/**
- * Reads and parses the contents of a file as JSON
- * @param filePath The path to the file
- * @returns The parsed content, or null if parsing fails
- */
-const readContents = async <T>(filePath: string): Promise<T | null> => {
-  const raw = await readFile(filePath, "utf-8");
-
-  try {
-    const contents = JSON.parse(raw);
-    return contents;
-  } catch (err) {
-    return null;
-  }
-};
-
-/**
- * Reads a value from a JSON config file by key
- * @param filePath Path to the JSON config file
- * @param key Key to extract from the parsed JSON
- * @returns The value at the given key, or null if file/key missing or invalid
- */
-const readConfigValue = async <T>(
-  filePath: string,
-  key: keyof T,
-): Promise<T[keyof T] | null> => {
-  const cfg = await readContents<T>(filePath);
-  return cfg?.[key] ?? null;
-};
-
-/**
- * Reads API key from Pi's auth file
- * @returns The API key, as defined by the auth.json file
- */
-export const resolveApiKey = async (): Promise<string> => {
-  const authPath = join(process.env.HOME || ".", ".pi", "agent", "auth.json");
-  if (!(await fileExists(authPath))) return API_KEY_PLACEHOLDER;
-
-  const cfg = await readConfigValue<AuthFile>(authPath, PROVIDER_ID);
-  return cfg?.key ?? API_KEY_PLACEHOLDER;
-};
-
-/**
- * Resolves the llama-server url by searching for it in the global settings.json file
- * @returns The URL, if found.
- */
-const resolveGlobalUrl = async (): Promise<string | null> => {
-  const globalPath = join(
-    process.env.HOME || ".",
-    ".pi",
-    "agent",
-    "settings.json",
-  );
-
-  if (!(await fileExists(globalPath))) return null;
-
-  return readConfigValue<Record<string, string>>(globalPath, "llamaServerUrl");
-};
-
-/**
- * Resolves the llama-server url by searching for it in the project's .pi/llama-server.json file
- * @param cwd The current working directory
- * @returns The URL, if found.
- */
-const resolveProjectUrl = async (cwd: string): Promise<string | null> => {
-  const projectPath = join(cwd, ".pi", "llama-server.json");
-
-  if (!(await fileExists(projectPath))) return null;
-  return readConfigValue<Record<string, string>>(projectPath, "url");
-};
-
-/**
- * Resolves the llama-server url by searching for it in the environment
- * @returns The URL, if found.
- */
-const resolveEnvUrl = async (): Promise<string | null> => {
-  return process.env.LLAMA_SERVER_URL ?? null;
-};
-
-/**
- * Tries all possible ways to retrieve the llama-server URL
- * @param cwd The current working directory
- * @returns The URL, or a default if not found
- */
-const resolveUrlWithFallbacks = async (cwd: string): Promise<string> => {
-  // 1. per-project config
-  let response = await resolveProjectUrl(cwd);
-  if (response) return response;
-
-  // 2. env
-  response = await resolveEnvUrl();
-  if (response) return response;
-
-  // 3. global settings: ~/.pi/agent/settings.json
-  response = await resolveGlobalUrl();
-  if (response) return response;
-
-  // 4. default
-  return DEFAULT_LLAMA_SERVER_URL;
-};
-
-/**
- * Resolves the URL where llama-server is running
- * @param cwd The current working directory
- * @returns The URL, or a default if not found
- */
-export const resolveUrl = async (cwd: string): Promise<string> => {
-  if (resolvedUrl) return resolvedUrl;
-  const result = await resolveUrlWithFallbacks(cwd);
-
-  // Strip trailing slashes
-  resolvedUrl = result.replace(/\/+$/, "");
-
-  return resolvedUrl;
-};

package/src/tools/retriever.ts

@@ -1,71 +0,0 @@
-import { HealthEndpoint } from "../interfaces/endpoints/health";
-import { ModelsEndpoint } from "../interfaces/endpoints/models";
-import { BaseModel } from "../models/baseModel";
-import { RouterModel } from "../models/routerModel";
-import { SingleModel } from "../models/singleModel";
-import { resolveApiKey, resolveUrl } from "./resolver";
-
-/**
- * Detects if the server is ready
- * @returns True if it's ready to work
- */
-export const isServerReady = async (): Promise<boolean> => {
-  try {
-    const { status } = await rpc<HealthEndpoint>("/health");
-    return status === "ok";
-  } catch {
-    return false;
-  }
-};
-
-/**
- * Makes an HTTP request to the llama-server and returns the parsed JSON response
- *
- * @param endpoint The endpoint path to fetch (e.g. "/health")
- * @param body The optional request body for POST requests
- * @returns The parsed JSON response from the server
- */
-export const rpc = async <T>(
-  endpoint: string,
-  body?: Record<string, unknown>,
-): Promise<T> => {
-  const base = await resolveUrl(process.cwd());
-  const url = `${base}${endpoint}`;
-
-  const data = {
-    method: body ? "POST" : "GET",
-    headers: body ? { "Content-Type": "application/json" } : undefined,
-    body: body ? JSON.stringify(body) : undefined,
-  };
-
-  const apiKey = await resolveApiKey();
-  const res = await fetch(url, {
-    ...data,
-    headers: {
-      ...data.headers,
-      ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
-    },
-  });
-
-  const response: T = await res.json();
-  return response;
-};
-
-/**
- * Retrieves a list of available models from llama-server
- * @param base Base URL to use
- * @returns The list of models
- */
-export const listModels = async (): Promise<BaseModel[]> => {
-  const { models, data } = await rpc<ModelsEndpoint>("/models");
-
-  if (models) {
-    return data.map((m) => new SingleModel(m));
-  }
-
-  const response = data
-    .map((m) => new RouterModel(m))
-    .sort((a, b) => (a.id > b.id ? 1 : a.id === b.id ? 0 : -1));
-
-  return response;
-};

package/tests/handlers.test.ts

@@ -1,164 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { Action } from "../src/enums/action";
-import { Mode } from "../src/enums/mode";
-import { Status } from "../src/enums/status";
-import { DataProperty } from "../src/interfaces/endpoints/models";
-
-// Mock the retriever module before importing anything that depends on it
-vi.mock("../src/tools/retriever", () => ({
-  rpc: vi.fn(),
-  isServerReady: vi.fn(),
-  listModels: vi.fn(),
-}));
-
-class TestModel {
-  constructor(
-    private readonly model: DataProperty,
-    private readonly _mode: Mode,
-    private readonly _status: Status,
-  ) {}
-
-  get mode(): Mode {
-    return this._mode;
-  }
-
-  get capabilities(): ["text"] | ["image"] {
-    return ["text"];
-  }
-
-  async getStatus(): Promise<Status> {
-    return this._status;
-  }
-
-  async getContextSize(): Promise<number> {
-    return 4096;
-  }
-}
-
-const createModel = (
-  mode: Mode,
-  status: Status,
-  overrides: Partial<DataProperty> = {},
-) =>
-  new TestModel(
-    {
-      id: "test",
-      tags: [],
-      object: "model",
-      owned_by: "test",
-      created: Date.now(),
-      ...overrides,
-    },
-    mode,
-    status,
-  );
-
-/**
- * Replicates the getActionsForModel logic from handlers.ts for testing
- * without needing the full Pi extension context.
- */
-const getActionsForModel = async (model: TestModel): Promise<Array<Action>> => {
-  const routerModeActions: Record<Status, Array<Action>> = {
-    [Status.LOADED]: [Action.SWITCH, Action.UNLOAD, Action.INFO, Action.CANCEL],
-    [Status.LOADING]: [Action.INFO, Action.CANCEL],
-    [Status.FAILED]: [Action.RETRY, Action.CANCEL],
-    [Status.SLEEPING]: [
-      Action.SWITCH,
-      Action.UNLOAD,
-      Action.INFO,
-      Action.CANCEL,
-    ],
-    [Status.UNLOADED]: [Action.LOAD, Action.CANCEL],
-  };
-
-  const singleModeActions: Record<Status, Array<Action>> = {
-    [Status.LOADED]: [Action.INFO, Action.CANCEL],
-    [Status.LOADING]: [Action.CANCEL],
-    [Status.FAILED]: [Action.CANCEL],
-    [Status.SLEEPING]: [Action.INFO, Action.CANCEL],
-    [Status.UNLOADED]: [Action.CANCEL],
-  };
-
-  const allActions =
-    model.mode === Mode.ROUTER ? routerModeActions : singleModeActions;
-
-  const status = await model.getStatus();
-  return allActions[status];
-};
-
-describe("Action availability", () => {
-  const actionMatrix: Array<{
-    mode: Mode;
-    status: Status;
-    expected: Action[];
-  }> = [
-    // Router mode
-    {
-      mode: Mode.ROUTER,
-      status: Status.LOADED,
-      expected: [Action.SWITCH, Action.UNLOAD, Action.INFO, Action.CANCEL],
-    },
-    {
-      mode: Mode.ROUTER,
-      status: Status.LOADING,
-      expected: [Action.INFO, Action.CANCEL],
-    },
-    {
-      mode: Mode.ROUTER,
-      status: Status.FAILED,
-      expected: [Action.RETRY, Action.CANCEL],
-    },
-    {
-      mode: Mode.ROUTER,
-      status: Status.SLEEPING,
-      expected: [Action.SWITCH, Action.UNLOAD, Action.INFO, Action.CANCEL],
-    },
-    {
-      mode: Mode.ROUTER,
-      status: Status.UNLOADED,
-      expected: [Action.LOAD, Action.CANCEL],
-    },
-    // Single mode
-    {
-      mode: Mode.SINGLE,
-      status: Status.LOADED,
-      expected: [Action.INFO, Action.CANCEL],
-    },
-    { mode: Mode.SINGLE, status: Status.LOADING, expected: [Action.CANCEL] },
-    { mode: Mode.SINGLE, status: Status.FAILED, expected: [Action.CANCEL] },
-    {
-      mode: Mode.SINGLE,
-      status: Status.SLEEPING,
-      expected: [Action.INFO, Action.CANCEL],
-    },
-    { mode: Mode.SINGLE, status: Status.UNLOADED, expected: [Action.CANCEL] },
-  ];
-
-  it.each(actionMatrix)(
-    "should return correct actions for $mode/$status",
-    async ({ mode, status, expected }) => {
-      const model = createModel(mode, status);
-      const actions = await getActionsForModel(model);
-      expect(actions).toEqual(expected);
-    },
-  );
-
-  it("should always include CANCEL regardless of mode or status", async () => {
-    for (const mode of [Mode.ROUTER, Mode.SINGLE]) {
-      for (const status of Object.values(Status)) {
-        const model = createModel(mode, status);
-        const actions = await getActionsForModel(model);
-        expect(actions).toContain(Action.CANCEL);
-      }
-    }
-  });
-
-  it("should not include mode-exclusive actions", async () => {
-    const singleLoaded = createModel(Mode.SINGLE, Status.LOADED);
-    expect(await getActionsForModel(singleLoaded)).not.toContain(Action.SWITCH);
-    expect(await getActionsForModel(singleLoaded)).not.toContain(Action.LOAD);
-
-    const singleFailed = createModel(Mode.SINGLE, Status.FAILED);
-    expect(await getActionsForModel(singleFailed)).not.toContain(Action.RETRY);
-  });
-});