@preapexis/pi-kit 1.0.13 → 1.1.0

package/extensions/litellm-provider.ts

@@ -0,0 +1,302 @@
+// cSpell:words litellm preapexis deepseek
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+type LiteLlmModelInfo = {
+  model_name?: string;
+  litellm_params?: {
+    model?: string;
+  };
+  model_info?: {
+    id?: string;
+    name?: string;
+    display_name?: string;
+    description?: string;
+    max_tokens?: number;
+    max_input_tokens?: number;
+    context_window?: number;
+    input_cost_per_token?: number;
+    output_cost_per_token?: number;
+    supports_vision?: boolean;
+    supports_function_calling?: boolean;
+    mode?: string;
+  };
+};
+
+type OpenAiModel = {
+  id?: string;
+  object?: string;
+  owned_by?: string;
+};
+
+type ModelPayload = {
+  data?: Array<LiteLlmModelInfo | OpenAiModel>;
+};
+
+type PiModel = {
+  id: string;
+  name: string;
+  reasoning: boolean;
+  input: Array<"text" | "image">;
+  cost: {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+  };
+  contextWindow: number;
+  maxTokens: number;
+  compat?: {
+    supportsDeveloperRole?: boolean;
+    supportsReasoningEffort?: boolean;
+  };
+};
+
+const PROVIDER_ID = "litellm";
+const DEFAULT_BASE_URL = "http://localhost:4000/v1";
+
+export default async function (pi: ExtensionAPI): Promise<void> {
+  const baseUrl = normalizeBaseUrl(
+    process.env.LITELLM_BASE_URL ?? DEFAULT_BASE_URL
+  );
+
+  async function registerLiteLlmProvider(): Promise<void> {
+    const models = await discoverModels(baseUrl);
+
+    pi.registerProvider(PROVIDER_ID, {
+      name: "LiteLLM",
+      baseUrl,
+      apiKey: "$LITELLM_API_KEY",
+      api: "openai-completions",
+      models
+    });
+  }
+
+  await registerLiteLlmProvider();
+
+  pi.registerCommand("litellm-refresh", {
+    description: "Refresh LiteLLM models from the LiteLLM proxy",
+    handler: async (_args, ctx) => {
+      try {
+        await registerLiteLlmProvider();
+
+        ctx.ui.notify(
+          [
+            "LiteLLM models refreshed.",
+            "",
+            `Base URL: ${baseUrl}`,
+            "",
+            "Run /model to select a LiteLLM model."
+          ].join("\n"),
+          "info"
+        );
+      } catch (error) {
+        ctx.ui.notify(
+          [
+            "LiteLLM model refresh failed.",
+            "",
+            error instanceof Error ? error.message : String(error)
+          ].join("\n"),
+          "error"
+        );
+      }
+    }
+  });
+}
+
+function normalizeBaseUrl(value: string): string {
+  return value.replace(/\/+$/, "");
+}
+
+function getProxyRoot(baseUrl: string): string {
+  return baseUrl.endsWith("/v1") ? baseUrl.slice(0, -3) : baseUrl;
+}
+
+async function discoverModels(baseUrl: string): Promise<PiModel[]> {
+  const proxyRoot = getProxyRoot(baseUrl);
+
+  const endpoints = [
+    `${proxyRoot}/v1/model/info`,
+    `${proxyRoot}/model/info`,
+    `${baseUrl}/models`
+  ];
+
+  for (const endpoint of endpoints) {
+    try {
+      const payload = await fetchModelPayload(endpoint);
+      const models = payloadToPiModels(payload);
+
+      if (models.length > 0) {
+        return models;
+      }
+    } catch {
+      // Try the next endpoint.
+    }
+  }
+
+  const fallbackModels = getFallbackModels();
+
+  if (fallbackModels.length > 0) {
+    return fallbackModels;
+  }
+
+  throw new Error(
+    [
+      "Could not discover LiteLLM models.",
+      "",
+      `Tried: ${endpoints.join(", ")}`,
+      "",
+      "Make sure LiteLLM is running and set LITELLM_API_KEY if your proxy requires auth.",
+      "You can also set LITELLM_MODELS as a comma-separated fallback."
+    ].join("\n")
+  );
+}
+
+async function fetchModelPayload(url: string): Promise<ModelPayload> {
+  const headers: Record<string, string> = {
+    accept: "application/json"
+  };
+
+  const apiKey = process.env.LITELLM_API_KEY;
+
+  if (apiKey) {
+    headers.authorization = `Bearer ${apiKey}`;
+  }
+
+  const response = await fetch(url, {
+    method: "GET",
+    headers
+  });
+
+  if (!response.ok) {
+    throw new Error(`${url} returned HTTP ${response.status}`);
+  }
+
+  return (await response.json()) as ModelPayload;
+}
+
+function payloadToPiModels(payload: ModelPayload): PiModel[] {
+  const data = Array.isArray(payload.data) ? payload.data : [];
+  const seen = new Set<string>();
+  const models: PiModel[] = [];
+
+  for (const item of data) {
+    const model = modelFromPayloadItem(item);
+
+    if (!model) continue;
+    if (seen.has(model.id)) continue;
+
+    seen.add(model.id);
+    models.push(model);
+  }
+
+  return models.sort((a, b) => a.id.localeCompare(b.id));
+}
+
+function modelFromPayloadItem(
+  item: LiteLlmModelInfo | OpenAiModel
+): PiModel | undefined {
+  const modelInfo = "model_info" in item ? item.model_info : undefined;
+
+  const id =
+    "model_name" in item && item.model_name
+      ? item.model_name
+      : "id" in item && item.id
+        ? item.id
+        : modelInfo?.id;
+
+  if (!id) return undefined;
+
+  const name = modelInfo?.display_name ?? modelInfo?.name ?? id;
+
+  const contextWindow =
+    modelInfo?.context_window ?? modelInfo?.max_input_tokens ?? 128000;
+
+  const maxTokens = modelInfo?.max_tokens ?? 4096;
+
+  const supportsVision =
+    modelInfo?.supports_vision === true || looksLikeVisionModel(id);
+
+  return {
+    id,
+    name,
+    reasoning: looksLikeReasoningModel(id),
+    input: supportsVision ? ["text", "image"] : ["text"],
+    cost: {
+      input: costPerMillion(modelInfo?.input_cost_per_token),
+      output: costPerMillion(modelInfo?.output_cost_per_token),
+      cacheRead: 0,
+      cacheWrite: 0
+    },
+    contextWindow,
+    maxTokens,
+    compat: {
+      supportsDeveloperRole: false,
+      supportsReasoningEffort: false
+    }
+  };
+}
+
+function costPerMillion(value: number | undefined): number {
+  if (typeof value !== "number" || Number.isNaN(value)) {
+    return 0;
+  }
+
+  return value * 1_000_000;
+}
+
+function looksLikeVisionModel(id: string): boolean {
+  const lower = id.toLowerCase();
+
+  return (
+    lower.includes("vision") ||
+    lower.includes("vl") ||
+    lower.includes("gpt-4o") ||
+    lower.includes("gemini") ||
+    lower.includes("claude")
+  );
+}
+
+function looksLikeReasoningModel(id: string): boolean {
+  const lower = id.toLowerCase();
+
+  return (
+    lower.includes("reason") ||
+    lower.includes("thinking") ||
+    lower.includes("o1") ||
+    lower.includes("o3") ||
+    lower.includes("o4") ||
+    lower.includes("r1") ||
+    lower.includes("deepseek")
+  );
+}
+
+function getFallbackModels(): PiModel[] {
+  const raw = process.env.LITELLM_MODELS;
+
+  if (!raw?.trim()) {
+    return [];
+  }
+
+  return raw
+    .split(",")
+    .map((value) => value.trim())
+    .filter(Boolean)
+    .map((id) => ({
+      id,
+      name: id,
+      reasoning: looksLikeReasoningModel(id),
+      input: looksLikeVisionModel(id) ? ["text", "image"] : ["text"],
+      cost: {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0
+      },
+      contextWindow: 128000,
+      maxTokens: 4096,
+      compat: {
+        supportsDeveloperRole: false,
+        supportsReasoningEffort: false
+      }
+    }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@preapexis/pi-kit",
-  "version": "1.0.13",
+  "version": "1.1.0",
   "description": "Personal Pi coding-agent kit with safety extensions, status UI, prompt workflows, skills, and themes.",
   "keywords": [
     "pi-package",
@@ -33,7 +33,7 @@
   "scripts": {
     "test": "vitest run",
     "test:watch": "vitest",
-    "release": "npm version patch && git push --follow-tags"
+    "git": "node scripts/git-release.mjs"
   },
   "devDependencies": {
     "typescript": "^5.5.0",

package/scripts/git-release.mjs

@@ -0,0 +1,144 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { stdin as input, stdout as output } from "node:process";
+import readline from "node:readline/promises";
+
+const rl = readline.createInterface({ input, output });
+
+const message =
+  process.env.npm_config_msg ||
+  process.argv.slice(2).join(" ") ||
+  "chore: release";
+
+function run(command, args) {
+  console.log(`\n> ${command} ${args.join(" ")}\n`);
+
+  const result = spawnSync(command, args, {
+    stdio: "inherit",
+    shell: true
+  });
+
+  if (result.status !== 0) {
+    console.error(`\nCommand failed: ${command} ${args.join(" ")}`);
+    process.exit(result.status ?? 1);
+  }
+}
+
+async function askYesNo(question, defaultValue = false) {
+  const suffix = defaultValue ? "Y/n" : "y/N";
+  const answer = (await rl.question(`${question} (${suffix}): `))
+    .trim()
+    .toLowerCase();
+
+  if (!answer) return defaultValue;
+
+  return answer === "y" || answer === "yes";
+}
+
+async function askVersionType() {
+  while (true) {
+    const answer = (await rl.question("Version bump type? patch/minor/major: "))
+      .trim()
+      .toLowerCase();
+
+    if (["patch", "minor", "major"].includes(answer)) {
+      return answer;
+    }
+
+    console.log("Please type patch, minor, or major.");
+  }
+}
+
+function readJson(path) {
+  return JSON.parse(readFileSync(path, "utf-8"));
+}
+
+function writeJson(path, data) {
+  writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`);
+}
+
+function bumpVersion(version, type) {
+  const parts = version.split(".").map(Number);
+
+  if (parts.length !== 3 || parts.some(Number.isNaN)) {
+    throw new Error(`Invalid version: ${version}`);
+  }
+
+  if (type === "major") {
+    parts[0] += 1;
+    parts[1] = 0;
+    parts[2] = 0;
+  }
+
+  if (type === "minor") {
+    parts[1] += 1;
+    parts[2] = 0;
+  }
+
+  if (type === "patch") {
+    parts[2] += 1;
+  }
+
+  return parts.join(".");
+}
+
+function updatePackageVersion(nextVersion) {
+  const pkg = readJson("package.json");
+
+  pkg.version = nextVersion;
+  writeJson("package.json", pkg);
+
+  if (existsSync("package-lock.json")) {
+    const lock = readJson("package-lock.json");
+
+    if (lock.version) {
+      lock.version = nextVersion;
+    }
+
+    if (lock.packages?.[""]) {
+      lock.packages[""].version = nextVersion;
+    }
+
+    writeJson("package-lock.json", lock);
+  }
+}
+
+try {
+  const shouldBump = await askYesNo(
+    "Do you want to bump package version?",
+    true
+  );
+  let nextVersion = null;
+  let tag = null;
+
+  if (shouldBump) {
+    const bumpType = await askVersionType();
+    const pkg = readJson("package.json");
+
+    nextVersion = bumpVersion(pkg.version, bumpType);
+    tag = `v${nextVersion}`;
+
+    updatePackageVersion(nextVersion);
+
+    console.log(`\nBumped version to ${nextVersion}\n`);
+  }
+
+  const shouldPublish = await askYesNo("Do you want to publish to npm?", false);
+
+  run("git", ["add", "."]);
+  run("git", ["commit", "-m", `"${message}"`]);
+
+  if (tag) {
+    run("git", ["tag", tag]);
+  }
+
+  run("git", ["push", "--follow-tags"]);
+
+  if (shouldPublish) {
+    run("npm", ["publish", "--access", "public"]);
+  }
+
+  console.log("\nDone.\n");
+} finally {
+  rl.close();
+}

package/tests/extensions.test.ts

@@ -1,49 +1,61 @@
-import { describe, it, expect } from "vitest";
-import * as path from "path";
-import {
-  listFiles,
-  readFile,
-  checkTypeScriptSyntax,
-  hasDefaultExport
-} from "./helpers";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+import { checkTypeScriptSyntax, listFiles, readFile } from "./helpers.js";
+
+function hasPiDefaultExport(source: string): boolean {
+  return (
+    /export\s+default\s+async\s+function\b/.test(source) ||
+    /export\s+default\s+function\b/.test(source) ||
+    /export\s+default\s+\(/.test(source) ||
+    /export\s*\{[^}]*\bas\s+default\b[^}]*\}/.test(source)
+  );
+}
 
 describe("extensions", () => {
   const extDir = path.resolve("extensions");
 
   it("should have at least one extension file", async () => {
     const files = await listFiles(extDir);
-    const tsFiles = files.filter((f) => f.endsWith(".ts"));
+    const tsFiles = files.filter((file: string) => file.endsWith(".ts"));
+
     expect(tsFiles.length).toBeGreaterThan(0);
   });
 
-  it("should export a default function", async () => {
+  it("should export a default extension function", async () => {
     const files = await listFiles(extDir);
-    const tsFiles = files.filter((f) => f.endsWith(".ts"));
+    const tsFiles = files.filter((file: string) => file.endsWith(".ts"));
 
     for (const file of tsFiles) {
       const source = await readFile(file);
-      expect(hasDefaultExport(source)).toBe(true);
+
+      expect(
+        hasPiDefaultExport(source),
+        `${path.basename(file)} should export a default function`
+      ).toBe(true);
     }
   });
 
-  it("should have no unexpected imports", async () => {
+  it("should have valid TypeScript syntax", async () => {
     const files = await listFiles(extDir);
-    const tsFiles = files.filter((f) => f.endsWith(".ts"));
+    const tsFiles = files.filter((file: string) => file.endsWith(".ts"));
 
     for (const file of tsFiles) {
       const source = await readFile(file);
       const result = checkTypeScriptSyntax(source, path.basename(file));
-      expect(result.errors).toEqual([]);
+
+      expect(result.errors, `${path.basename(file)} has syntax errors`).toEqual(
+        []
+      );
     }
   });
 
-  it("should not contain duplicate responsibilities (by name)", async () => {
+  it("should not contain duplicate extension file names", async () => {
     const files = await listFiles(extDir);
-    const tsFiles = files.filter((f) => f.endsWith(".ts"));
+    const tsFiles = files.filter((file: string) => file.endsWith(".ts"));
 
-    // Each extension should have a unique, focused name
-    const names = tsFiles.map((f) => path.basename(f, ".ts"));
+    const names = tsFiles.map((file: string) => path.basename(file, ".ts"));
     const uniqueNames = new Set(names);
+
     expect(uniqueNames.size).toBe(names.length);
   });
 });