@mathzdevolper/phantomcode-cli 1.0.0 → 2.0.0

package/bin/phantomcode.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require("../src/cli");

package/package.json

@@ -1,34 +1,14 @@
 {
   "name": "@mathzdevolper/phantomcode-cli",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "PhantomCode - CLI para DogRouter AI Integration Platform",
-  "main": "dist/index.js",
+  "main": "src/cli.js",
   "bin": {
-    "phantomcode": "dist/index.js"
+    "phantomcode": "bin/phantomcode.js"
   },
-  "scripts": {
-    "build": "tsc",
-    "start": "node dist/index.js",
-    "dev": "ts-node src/index.ts",
-    "prepublishOnly": "npm run build"
-  },
-  "keywords": ["dogrouter", "cli", "ai", "phantomcode"],
-  "author": "",
-  "license": "MIT",
   "type": "commonjs",
-  "dependencies": {
-    "chalk": "^4.1.2",
-    "conf": "^15.1.0",
-    "openai": "^6.42.0",
-    "ora": "^5.4.1",
-    "uuid": "^11.1.0",
-    "yargs": "^17.7.2"
+  "engines": {
+    "node": ">=18"
   },
-  "devDependencies": {
-    "@types/node": "^22.12.0",
-    "@types/uuid": "^10.0.0",
-    "@types/yargs": "^17.0.33",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.7.3"
-  }
+  "license": "MIT"
 }

package/src/cli.js

@@ -0,0 +1,65 @@
+const { chatCommand } = require("./commands/chat");
+const { configSetCommand, configGetCommand, configResetCommand, configSetModelCommand } = require("./commands/config");
+const { modelsCommand } = require("./commands/models");
+const { interactiveCommand } = require("./commands/interactive");
+const { banner, box, gray, green, red, cyan, bold, yellow } = require("./logger");
+
+const pkg = require("../package.json");
+
+function help() {
+  console.log(`
+${gray("Usage:")}
+  phantomcode chat [model] <message>    ${gray("Send a message")}
+  phantomcode interactive [model]       ${gray("Interactive mode")}
+  phantomcode models                    ${gray("List available models")}
+  phantomcode config set <api-key>      ${gray("Set API key")}
+  phantomcode config get                ${gray("Show config")}
+  phantomcode config reset              ${gray("Remove API key")}
+  phantomcode config set-model <model>  ${gray("Set default model")}
+  phantomcode -v, --version             ${gray("Show version")}
+  phantomcode -h, --help                ${gray("Show help")}
+
+${gray("Examples:")}
+  phantomcode config set sk-xxxxx
+  phantomcode chat gpt-5.5 "hello world"
+  phantomcode interactive deepseek-v4-pro
+`);
+}
+
+async function main() {
+  const [, , cmdRaw, ...args] = process.argv;
+  const cmd = String(cmdRaw || "").trim().toLowerCase();
+
+  if (!cmd || cmd === "-h" || cmd === "--help" || cmd === "help") {
+    console.log(banner());
+    help();
+    return;
+  }
+
+  if (cmd === "-v" || cmd === "--version" || cmd === "version") {
+    console.log(`PhantomCode v${pkg.version}`);
+    return;
+  }
+
+  if (cmd === "chat") return chatCommand(args);
+  if (cmd === "interactive" || cmd === "i") return interactiveCommand(args);
+  if (cmd === "models") return modelsCommand();
+
+  if (cmd === "config") {
+    const sub = String(args[0] || "").toLowerCase();
+    if (sub === "set") return configSetCommand(args.slice(1).join(" "));
+    if (sub === "get") return configGetCommand();
+    if (sub === "reset") return configResetCommand();
+    if (sub === "set-model") return configSetModelCommand(args.slice(1).join(" "));
+    console.log(red("[-] Use: phantomcode config set/get/reset/set-model"));
+    return;
+  }
+
+  console.log(red(`[-] Unknown command: ${cmd}`));
+  help();
+}
+
+main().catch((err) => {
+  console.error(red("Fatal error:"), err);
+  process.exit(1);
+});

package/src/commands/chat.js

@@ -0,0 +1,50 @@
+const { getApiKey, getDefaultModel, createSession, addMessage, getSession } = require("../config");
+const { drChat } = require("../hf");
+const { banner, gray, green, red, cyan, yellow } = require("../logger");
+
+async function chatCommand(args) {
+  console.log(banner());
+
+  let apiKey;
+  try {
+    apiKey = getApiKey();
+  } catch {
+    console.log(red("[-] API key nao configurada"));
+    console.log(gray("    Execute: phantomcode config set <sua-api-key>"));
+    return;
+  }
+
+  const model = args[0] || getDefaultModel();
+  const message = args.slice(1).join(" ");
+
+  if (!message) {
+    console.log(red("[-] Use: phantomcode chat <model> <mensagem>"));
+    return;
+  }
+
+  const messages = [];
+  messages.push({ role: "user", content: message });
+
+  console.log(gray(`model: ${model}`));
+  console.log(gray(`Você: ${message}`));
+  console.log();
+
+  try {
+    const response = await drChat({ apiKey, model, messages });
+
+    console.log(cyan(`Phantom: ${response.content}`));
+
+    if (response.usage) {
+      console.log(gray(`model: ${response.model} | tokens: ${response.usage.promptTokens}→${response.usage.completionTokens} (${response.usage.totalTokens})`));
+    }
+
+    const session = createSession(model, message);
+    addMessage(session.id, "user", message);
+    addMessage(session.id, "assistant", response.content);
+    console.log(gray(`session: ${session.id}`));
+  } catch (err) {
+    console.log(red(`[-] ${err.message || "Erro"}`));
+  }
+}
+
+module.exports = { chatCommand };

package/src/commands/config.js

@@ -0,0 +1,35 @@
+const { loadConfig, saveConfig, getApiKey, setApiKey, removeApiKey, hasApiKey, getDefaultModel, setDefaultModel } = require("../config");
+const { banner, box, gray, green, red, cyan, yellow } = require("../logger");
+
+async function configSetCommand(key) {
+  if (!key) {
+    console.log(red("[-] Use: phantomcode config set <api-key>"));
+    return;
+  }
+  setApiKey(key);
+  console.log(green("[+] API key configurada com sucesso"));
+}
+
+async function configGetCommand() {
+  const cfg = loadConfig();
+  console.log(box("Config", [
+    `API Key: ${cfg.apiKey ? cyan(cfg.apiKey.slice(0, 12) + "...") : gray("nao definida")}`,
+    `Default Model: ${cyan(cfg.defaultModel || "dogrouter/auto")}`,
+  ].join("\n")));
+}
+
+async function configResetCommand() {
+  removeApiKey();
+  console.log(yellow("[!] API key removida"));
+}
+
+async function configSetModelCommand(model) {
+  if (!model) {
+    console.log(red("[-] Use: phantomcode config set-model <model>"));
+    return;
+  }
+  setDefaultModel(model);
+  console.log(green(`[+] Modelo padrao: ${cyan(model)}`));
+}
+
+module.exports = { configSetCommand, configGetCommand, configResetCommand, configSetModelCommand };

package/src/commands/interactive.js

@@ -0,0 +1,87 @@
+const readline = require("readline/promises");
+const { stdin, stdout } = require("process");
+const { getApiKey, getDefaultModel, createSession, addMessage, getSession } = require("../config");
+const { drChat } = require("../hf");
+const { banner, gray, green, red, cyan, yellow } = require("../logger");
+
+async function ask(question) {
+  const rl = readline.createInterface({ input: stdin, output: stdout });
+  try {
+    return (await rl.question(question)).trim();
+  } finally {
+    rl.close();
+  }
+}
+
+async function interactiveCommand(args) {
+  console.log(banner());
+
+  let apiKey;
+  try {
+    apiKey = getApiKey();
+  } catch {
+    console.log(red("[-] API key nao configurada"));
+    console.log(gray("    Execute: phantomcode config set <sua-api-key>"));
+    return;
+  }
+
+  const model = args[0] || getDefaultModel();
+  let sessionId = null;
+  const messages = [];
+
+  console.log(gray(`model: ${model}`));
+  console.log(gray("Comandos: /exit /clear /new /help"));
+  console.log();
+
+  while (true) {
+    const input = await ask(cyan("» "));
+
+    if (!input || input === "/exit" || input === "/quit") break;
+
+    if (input === "/help") {
+      console.log(gray("  /exit  /quit  — Sair"));
+      console.log(gray("  /clear        — Limpar tela"));
+      console.log(gray("  /new          — Nova conversa"));
+      console.log(gray("  /help         — Ajuda"));
+      continue;
+    }
+
+    if (input === "/clear") {
+      console.clear();
+      console.log(banner());
+      console.log(gray(`model: ${model}`));
+      continue;
+    }
+
+    if (input === "/new") {
+      messages.length = 0;
+      sessionId = null;
+      console.log(green("[+] Nova conversa"));
+      continue;
+    }
+
+    messages.push({ role: "user", content: input });
+
+    try {
+      const response = await drChat({ apiKey, model, messages });
+      console.log(`\n${cyan("Phantom:")} ${response.content}\n`);
+      messages.push({ role: "assistant", content: response.content });
+
+      if (sessionId) {
+        addMessage(sessionId, "user", input);
+        addMessage(sessionId, "assistant", response.content);
+      } else {
+        const session = createSession(model, input);
+        sessionId = session.id;
+        addMessage(sessionId, "user", input);
+        addMessage(sessionId, "assistant", response.content);
+      }
+    } catch (err) {
+      console.log(red(`[-] ${err.message || "Erro"}`));
+    }
+  }
+
+  console.log(gray(`\nSession: ${sessionId || "none"}`));
+}
+
+module.exports = { interactiveCommand };

package/src/commands/models.js

@@ -0,0 +1,35 @@
+const { getApiKey } = require("../config");
+const { drListModels } = require("../hf");
+const { buildModelCatalog } = require("../models");
+const { banner, box, gray, green, red, cyan } = require("../logger");
+
+async function modelsCommand() {
+  console.log(banner());
+
+  let apiKey;
+  try {
+    apiKey = getApiKey();
+  } catch {
+    console.log(red("[-] API key nao configurada"));
+    console.log(gray("    Execute: phantomcode config set <sua-api-key>"));
+    return;
+  }
+
+  let live = [];
+  try {
+    const raw = await drListModels(apiKey);
+    live = raw.slice(0, 40).map((m) => ({
+      id: m.id,
+      label: m.id.split("/").pop(),
+      note: "live",
+    }));
+  } catch {}
+
+  const models = buildModelCatalog(live);
+  const lines = models.map((m, i) =>
+    `${String(i + 1).padStart(2, "0")}. ${m.label}${m.note ? " — " + m.note : ""}`
+  );
+  console.log(box(`Models (${models.length})`, lines.join("\n")));
+}
+
+module.exports = { modelsCommand };

package/src/config.js

@@ -0,0 +1,135 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const CONFIG_DIR = path.join(os.homedir(), ".phantomcode");
+const CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+const SESSIONS_DIR = path.join(CONFIG_DIR, "sessions");
+
+function ensureDir(dir) {
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+  } catch {}
+}
+
+function loadConfig() {
+  ensureDir(CONFIG_DIR);
+  try {
+    return JSON.parse(fs.readFileSync(CONFIG_PATH, "utf8"));
+  } catch {
+    return { apiKey: "", defaultModel: "dogrouter/auto" };
+  }
+}
+
+function saveConfig(config) {
+  ensureDir(CONFIG_DIR);
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), "utf8");
+  try { fs.chmodSync(CONFIG_PATH, 0o600); } catch {}
+}
+
+function getApiKey() {
+  const cfg = loadConfig();
+  if (!cfg.apiKey) throw new Error("API key nao configurada");
+  return cfg.apiKey;
+}
+
+function setApiKey(key) {
+  const cfg = loadConfig();
+  cfg.apiKey = key;
+  saveConfig(cfg);
+}
+
+function removeApiKey() {
+  const cfg = loadConfig();
+  cfg.apiKey = "";
+  saveConfig(cfg);
+}
+
+function hasApiKey() {
+  try {
+    return !!getApiKey();
+  } catch {
+    return false;
+  }
+}
+
+function getDefaultModel() {
+  const cfg = loadConfig();
+  return cfg.defaultModel || "dogrouter/auto";
+}
+
+function setDefaultModel(model) {
+  const cfg = loadConfig();
+  cfg.defaultModel = model;
+  saveConfig(cfg);
+}
+
+function getAll() {
+  return loadConfig();
+}
+
+// Session management
+function sessionPath(id) {
+  ensureDir(SESSIONS_DIR);
+  return path.join(SESSIONS_DIR, `${id}.json`);
+}
+
+function createId() {
+  return Date.now().toString(36) + Math.random().toString(36).slice(2, 8) + Math.random().toString(36).slice(2, 6);
+}
+
+function createSession(model, title) {
+  ensureDir(SESSIONS_DIR);
+  const id = createId();
+
+  const session = { id, title: title || "Nova sessao", model, messages: [], createdAt: Date.now(), updatedAt: Date.now() };
+  fs.writeFileSync(sessionPath(id), JSON.stringify(session, null, 2));
+  return session;
+}
+
+function getSession(id) {
+  try {
+    return JSON.parse(fs.readFileSync(sessionPath(id), "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function listSessions() {
+  ensureDir(SESSIONS_DIR);
+  try {
+    const files = fs.readdirSync(SESSIONS_DIR).filter((f) => f.endsWith(".json"));
+    return files
+      .map((f) => {
+        try { return JSON.parse(fs.readFileSync(path.join(SESSIONS_DIR, f), "utf8")); } catch { return null; }
+      })
+      .filter(Boolean)
+      .sort((a, b) => b.updatedAt - a.updatedAt);
+  } catch {
+    return [];
+  }
+}
+
+function addMessage(sessionId, role, content) {
+  const session = getSession(sessionId);
+  if (!session) return null;
+  session.messages.push({ role, content, timestamp: Date.now() });
+  session.updatedAt = Date.now();
+  if (session.messages.length === 1) {
+    session.title = content.slice(0, 50) + (content.length > 50 ? "..." : "");
+  }
+  fs.writeFileSync(sessionPath(sessionId), JSON.stringify(session, null, 2));
+  return session;
+}
+
+function deleteSession(id) {
+  try { fs.unlinkSync(sessionPath(id)); } catch {}
+}
+
+module.exports = {
+  CONFIG_DIR, CONFIG_PATH, SESSIONS_DIR,
+  loadConfig, saveConfig,
+  getApiKey, setApiKey, removeApiKey, hasApiKey,
+  getDefaultModel, setDefaultModel, getAll,
+  createSession, getSession, listSessions, addMessage, deleteSession,
+};

package/src/hf.js

@@ -0,0 +1,67 @@
+const BASE_URL = "https://api.dogrouter.ai/v1";
+
+async function drRequest(apiKey, endpoint, options = {}) {
+  const resp = await fetch(`${BASE_URL}${endpoint}`, {
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`,
+      ...(options.headers || {}),
+    },
+  });
+
+  const text = await resp.text();
+
+  if (!resp.ok) {
+    const err = new Error(`${resp.status} ${resp.statusText} — ${text.slice(0, 200)}`);
+    err.status = resp.status;
+    err.body = text;
+    throw err;
+  }
+
+  return text;
+}
+
+async function drChat({ apiKey, model, messages, temperature = 0.7, max_tokens }) {
+  const body = { model: model || "dogrouter/auto", messages, temperature };
+  if (max_tokens) body.max_tokens = max_tokens;
+
+  const text = await drRequest(apiKey, "/chat/completions", {
+    method: "POST",
+    body: JSON.stringify(body),
+  });
+
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    const err = new Error(`Invalid JSON: ${text.slice(0, 500)}`);
+    err.body = text;
+    throw err;
+  }
+
+  const content = data?.choices?.[0]?.message?.content;
+  if (content === undefined || content === null) {
+    const err = new Error("DR API returned no content");
+    err.raw = data;
+    throw err;
+  }
+
+  return {
+    content,
+    model: data.model,
+    usage: data.usage ? {
+      promptTokens: data.usage.prompt_tokens,
+      completionTokens: data.usage.completion_tokens,
+      totalTokens: data.usage.total_tokens,
+    } : null,
+  };
+}
+
+async function drListModels(apiKey) {
+  const text = await drRequest(apiKey, "/models");
+  const data = JSON.parse(text);
+  return (data?.data || []).map((m) => ({ id: m.id, ownedBy: m.owned_by || "" }));
+}
+
+module.exports = { BASE_URL, drChat, drListModels };

package/src/logger.js

@@ -0,0 +1,84 @@
+const A = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  blue: "\x1b[34m",
+  magenta: "\x1b[35m",
+  cyan: "\x1b[36m",
+  gray: "\x1b[90m",
+};
+
+function c(code, text) {
+  return `${code}${text}${A.reset}`;
+}
+
+function now() {
+  const d = new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+}
+
+function banner() {
+  const logo = [
+    `${c(A.cyan, "██████╗ ██╗  ██╗ █████╗ ███╗   ██╗████████╗ ██████╗ ███╗   ███╗ ██████╗ ██████╗ ███████╗")}`,
+    `${c(A.blue, "██╔══██╗██║  ██║██╔══██╗████╗  ██║╚══██╔══╝██╔═══██╗████╗ ████║██╔════╝██╔══██╗██╔════╝")}`,
+    `${c(A.magenta, "██████╔╝███████║██║  ██║██╔██╗ ██║   ██║   ██║   ██║██╔████╔██║██║     ██║  ██║█████╗  ")}`,
+    `${c(A.gray, "██╔═══╝ ██╔══██║██║  ██║██║╚██╗██║   ██║   ██║   ██║██║╚██╔╝██║██║     ██║  ██║██╔══╝  ")}`,
+    `${c(A.dim, "██║     ██║  ██║╚█████╔╝██║ ╚████║   ██║   ╚██████╔╝██║ ╚═╝ ██║╚██████╗██████╔╝███████╗")}`,
+    `${c(A.gray, "╚═╝     ╚═╝  ╚═╝ ╚════╝ ╚═╝  ╚═══╝   ╚═╝    ╚═════╝ ╚═╝     ╚═╝ ╚═════╝╚═════╝ ╚══════╝")}`,
+    `${c(A.gray, "DogRouter AI CLI")} ${c(A.dim, now())}`,
+  ].join("\n");
+  return logo;
+}
+
+function box(title, body = "") {
+  const lines = String(body).split("\n");
+  const width = Math.max(48, title.length + 8, ...lines.map((l) => l.length + 2));
+
+  const top = `┌${"─".repeat(width - 2)}┐`;
+  const head = `│ ${title}${" ".repeat(width - 3 - title.length)}│`;
+  const sep = `├${"─".repeat(width - 2)}┤`;
+  const content = lines.length
+    ? lines.map((l) => `│ ${l}${" ".repeat(width - 3 - l.length)}│`).join("\n")
+    : `│${" ".repeat(width - 2)}│`;
+  const bottom = `└${"─".repeat(width - 2)}┘`;
+
+  return [top, head, sep, content, bottom].join("\n");
+}
+
+function info(msg) {
+  console.log(`${c(A.cyan, "[*]")} ${msg}`);
+}
+function ok(msg) {
+  console.log(`${c(A.green, "[+]")} ${msg}`);
+}
+function warn(msg) {
+  console.log(`${c(A.yellow, "[!]")} ${msg}`);
+}
+function fail(msg) {
+  console.log(`${c(A.red, "[-]")} ${msg}`);
+}
+
+function gray(msg) {
+  return c(A.gray, msg);
+}
+function green(msg) {
+  return c(A.green, msg);
+}
+function yellow(msg) {
+  return c(A.yellow, msg);
+}
+function red(msg) {
+  return c(A.red, msg);
+}
+function cyan(msg) {
+  return c(A.cyan, msg);
+}
+function bold(msg) {
+  return c(A.bold, msg);
+}
+
+module.exports = { A, c, banner, box, info, ok, warn, fail, gray, green, yellow, red, cyan, bold, now };

package/src/models.js

@@ -0,0 +1,49 @@
+const DEFAULT_MODELS = [
+  { id: "gpt-5.5", label: "GPT 5.5", kind: "code/reasoning", note: "best overall" },
+  { id: "deepseek-v4-pro", label: "DeepSeek V4 Pro", kind: "code/reasoning", note: "agent tasks" },
+  { id: "deepseek-v4-flash", label: "DeepSeek V4 Flash", kind: "fast", note: "cheap and fast" },
+  { id: "deepseek-chat-v3.1", label: "DeepSeek Chat V3.1", kind: "general", note: "solid all-rounder" },
+  { id: "deepseek-v3.2", label: "DeepSeek V3.2", kind: "general", note: "updated" },
+  { id: "glm-5.1", label: "GLM 5.1", kind: "general", note: "zhipu ai" },
+  { id: "glm-5", label: "GLM 5", kind: "general", note: "zhipu ai" },
+  { id: "grok-4.3", label: "Grok 4.3", kind: "general", note: "xAI model" },
+  { id: "qwen3.6-plus", label: "Qwen 3.6 Plus", kind: "code", note: "strong coding" },
+  { id: "qwen3.5-plus", label: "Qwen 3.5 Plus", kind: "code", note: "coding" },
+  { id: "qwen3.5-35b-a3b", label: "Qwen 3.5 35B", kind: "general", note: "efficient" },
+  { id: "qwen3.5-27b", label: "Qwen 3.5 27B", kind: "general", note: "balanced" },
+  { id: "qwen3.5-flash", label: "Qwen 3.5 Flash", kind: "fast", note: "fast" },
+  { id: "qwen3.5-9b", label: "Qwen 3.5 9B", kind: "fast", note: "lightweight" },
+  { id: "MiniMax-M2.7", label: "MiniMax M2.7", kind: "general", note: "latest minimax" },
+  { id: "MiniMax-M2.5", label: "MiniMax M2.5", kind: "general", note: "stable" },
+  { id: "claude-sonnet-4-6", label: "Claude Sonnet 4.6", kind: "code", note: "sonnet" },
+  { id: "claude-opus-4-6", label: "Claude Opus 4.6", kind: "reasoning", note: "opus" },
+  { id: "claude-opus-4-7", label: "Claude Opus 4.7", kind: "reasoning", note: "latest opus" },
+  { id: "claude-opus-4-8", label: "Claude Opus 4.8", kind: "reasoning", note: "bleeding edge" },
+  { id: "claude-fable-5", label: "Claude Fable 5", kind: "creative", note: "creative" },
+  { id: "claude-jupiter-v1-p", label: "Claude Jupiter V1", kind: "reasoning", note: "jupiter preview" },
+  { id: "gemini-3-flash-preview", label: "Gemini 3 Flash", kind: "fast", note: "google flash" },
+  { id: "gemini-3.1-pro-preview", label: "Gemini 3.1 Pro", kind: "reasoning", note: "google pro" },
+  { id: "gpt-5.3-codex", label: "GPT 5.3 Codex", kind: "code", note: "codex" },
+  { id: "gpt-5.4-mini", label: "GPT 5.4 Mini", kind: "fast", note: "compact" },
+  { id: "kimi-k2.6", label: "Kimi K2.6", kind: "general", note: "kimi" },
+  { id: "kling-v3", label: "Kling V3", kind: "vision", note: "video/image" },
+  { id: "kling-v2-5-turbo", label: "Kling V2.5 Turbo", kind: "vision", note: "video/image" },
+  { id: "gpt-image-1.5", label: "GPT Image 1.5", kind: "vision", note: "image gen" },
+  { id: "gpt-image-1-mini", label: "GPT Image 1 Mini", kind: "vision", note: "image gen fast" },
+  { id: "gpt-image-2", label: "GPT Image 2", kind: "vision", note: "latest image" },
+];
+
+function byLabel(a, b) {
+  return a.label.localeCompare(b.label);
+}
+
+function buildModelCatalog(extra = []) {
+  const map = new Map();
+  for (const m of [...DEFAULT_MODELS, ...extra]) {
+    if (!m?.id) continue;
+    map.set(m.id, { ...m });
+  }
+  return [...map.values()].sort(byLabel);
+}
+
+module.exports = { DEFAULT_MODELS, buildModelCatalog };

package/dist/commands/chat.d.ts

@@ -1,9 +0,0 @@
-interface ChatArgs {
-    message: string;
-    model?: string;
-    noSave?: boolean;
-    session?: string;
-    system?: string;
-}
-export declare function handleChat(args: ChatArgs): Promise<void>;
-export {};