@baryonlabs/cli 0.1.0

package/LICENSE

@@ -0,0 +1,24 @@
+Baryon CLI — Proprietary License
+Copyright (c) 2026 Baryon Labs. All rights reserved.
+
+This package (@baryonlabs/cli) is distributed by Baryon Labs for use with the
+baryon.ai platform and the bundled pi coding agent.
+
+Permission is granted to install and use this package, in source or binary
+form, solely to access Baryon Labs services and authorized model providers.
+
+You may NOT, without prior written permission from Baryon Labs:
+  - redistribute, sublicense, sell, or rent this package;
+  - modify, fork, reverse engineer, or create derivative works for
+    redistribution;
+  - remove or alter this notice or any Baryon Labs branding.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+OR OTHER DEALINGS IN THE SOFTWARE.
+
+The bundled @earendil-works/pi-coding-agent is licensed separately by its
+respective authors. Contact: support@baryon.ai

package/README.md

@@ -0,0 +1,84 @@
+# @baryonlabs/cli
+
+> Baryon CLI — **AI 코딩·학습 에이전트**. `baryon.ai` API에 기본 연결된 [pi](https://www.npmjs.com/package/@earendil-works/pi-coding-agent) 코딩 에이전트 래퍼.
+
+한 줄 설치, 별도 키 설정 없이 시작, 상용·로컬 모델 무중단 전환. 교육기관 납품용으로 설계되었습니다.
+
+```bash
+npm install -g @baryonlabs/cli   # 또는 pnpm / yarn / bun
+baryon setup                     # baryon.ai API 키 등록 (1회)
+baryon                           # 코딩 에이전트 시작
+```
+
+`curl` 한 줄 설치:
+
+```bash
+curl -fsSL https://cli.baryon.ai/install.sh | sh
+```
+
+## 무엇을 하나요
+
+`@baryonlabs/cli` 는 pi 코딩 에이전트를 **baryon.ai (OpenAI 호환) API** 에 연결합니다. `baryon setup` 은:
+
+1. `~/.baryon/config.json` 에 API 키·엔드포인트를 저장하고 (권한 `600`),
+2. `${BARYON_BASE_URL}/models` 로 모델 목록을 조회해 (오프라인이면 기본값 사용),
+3. pi 의 `~/.pi/agent/models.json` 에 `baryon` 프로바이더를 **다른 프로바이더를 보존하며** 병합합니다.
+
+이후 `baryon` 은 `--provider baryon` 을 자동 주입해 pi 를 실행합니다. `--provider`/`--model`/`--api-key` 를 직접 주면 그 선택을 그대로 따르므로 **모델 비교**가 자유롭습니다.
+
+## 명령어
+
+| 명령 | 설명 |
+|------|------|
+| `baryon` | 대화형 코딩 에이전트 시작 (baryon.ai 기본) |
+| `baryon setup` | API 키 등록 + pi 프로바이더 구성 |
+| `baryon config` | 현재 설정 보기 (`--key`, `--base-url`, `--model` 로 변경) |
+| `baryon models` | 사용 가능한 모델 목록 (`pi --list-models` 패스스루) |
+| `baryon doctor` | 설치·연결 진단 |
+| `baryon update` | CLI + pi 에이전트 업데이트 |
+| `baryon help` | 도움말 |
+
+그 외 모든 인자(`-p`, `@file`, `--mode json`, `--continue` 등)는 pi 로 그대로 전달됩니다.
+
+```bash
+baryon -p "이 CSV를 분석해 차트를 만들어줘"   # 단발 실행
+baryon @report.md "요약해줘"                  # 파일 첨부
+baryon --provider openai                       # 다른 모델로 전환·비교
+```
+
+## 설정
+
+| 항목 | 기본값 | 재정의 |
+|------|--------|--------|
+| base URL | `https://api.baryon.ai/v1` | `BARYON_BASE_URL` 환경변수 또는 `baryon config --base-url` |
+| API key | — | `BARYON_API_KEY` 환경변수 또는 `baryon setup` |
+| 기본 모델 | 조회된 첫 모델 | `baryon config --model <id>` |
+
+> 정확한 엔드포인트·모델 ID 는 기관의 baryon.ai 플랜에 따릅니다.
+
+## 오프라인 / 폐쇄망
+
+인터넷 없이도 동작합니다. 로컬 LLM(Ollama·LM Studio·vLLM)을 쓰려면:
+
+```bash
+baryon config --base-url http://localhost:11434/v1 --key ollama
+baryon setup --base-url http://localhost:11434/v1
+```
+
+## 프로그래밍 사용
+
+```js
+import { configure, run } from "@baryonlabs/cli";
+
+await configure({ apiKey: process.env.BARYON_API_KEY });
+const code = await run(["-p", "Summarize README.md"]);
+```
+
+## 요구사항
+
+- Node.js ≥ 22.19
+- Docker 불필요, 빌드 과정 없음
+
+---
+
+문서: <https://cli.baryon.ai> · 문의: support@baryon.ai · © Baryon Labs

package/bin/baryon.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+// Baryon CLI entry. Built-in subcommands are handled locally; everything else
+// is forwarded to the pi coding agent with the baryon.ai provider pre-selected.
+import {
+  setup,
+  doctor,
+  models,
+  configCmd,
+  update,
+  help,
+  welcome,
+} from "../src/commands.js";
+import { loadConfig, piProviderConfigured, hasConfig } from "../src/config.js";
+import { runPi, resolvePiEntry } from "../src/pi.js";
+import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+import { c, err, log, sym } from "../src/ui.js";
+
+const require = createRequire(import.meta.url);
+
+function showVersion() {
+  const self = require("../package.json").version;
+  log(`@baryonlabs/cli ${c.lime("v" + self)}`);
+  const entry = resolvePiEntry();
+  if (entry) {
+    const r = spawnSync(process.execPath, [entry, "--version"], {
+      encoding: "utf8",
+    });
+    if (r.stdout) log(`pi ${c.dim(r.stdout.trim())}`);
+  }
+  return 0;
+}
+
+const argv = process.argv.slice(2);
+const cmd = argv[0];
+const rest = argv.slice(1);
+
+async function main() {
+  switch (cmd) {
+    case "setup":
+    case "login":
+    case "init":
+      return setup(rest);
+    case "doctor":
+      return doctor();
+    case "models":
+      return models(rest);
+    case "config":
+      return configCmd(rest);
+    case "update":
+    case "upgrade":
+      return update();
+    case "_welcome": // internal: postinstall hint
+      return welcome();
+    case "help":
+    case "--help":
+    case "-h":
+      return help();
+    case "version":
+    case "--version":
+    case "-v":
+      return showVersion();
+    default: {
+      // Everything else → pi. Nudge to setup if nothing is configured yet.
+      const unconfigured =
+        !hasConfig() && !piProviderConfigured() && !process.env.BARYON_API_KEY;
+      const userTargets = argv.some((a) =>
+        ["--provider", "--model", "--api-key"].includes(a),
+      );
+      if (unconfigured && !userTargets) {
+        if (process.stdin.isTTY) {
+          log(
+            `  ${sym.warn} ${c.yellow("아직 설정되지 않았습니다.")} ${c.lime("baryon setup")} ${c.dim("을 먼저 실행합니다.")}\n`,
+          );
+          return setup([]);
+        }
+        log(
+          `  ${sym.warn} ${c.yellow("설정이 없습니다.")} ${c.lime("baryon setup")} ${c.dim("을 먼저 실행하세요.")}`,
+        );
+        return 1;
+      }
+      const cfg = loadConfig();
+      return runPi(argv, cfg);
+    }
+  }
+}
+
+main()
+  .then((code) => process.exit(typeof code === "number" ? code : 0))
+  .catch((e) => {
+    err(e?.message || String(e));
+    process.exit(1);
+  });

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@baryonlabs/cli",
+  "version": "0.1.0",
+  "description": "Baryon CLI — AI 코딩·학습 에이전트. baryon.ai API에 기본 연결된 pi 코딩 에이전트 래퍼. 한 줄 설치, 상용·로컬 모델 전환.",
+  "type": "module",
+  "bin": {
+    "baryon": "bin/baryon.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "scripts": {
+    "test": "node --test",
+    "postinstall": "node ./bin/baryon.js _welcome || true"
+  },
+  "dependencies": {
+    "@earendil-works/pi-coding-agent": "^0.78.0"
+  },
+  "keywords": [
+    "baryon",
+    "baryon.ai",
+    "ai",
+    "coding-agent",
+    "cli",
+    "pi",
+    "llm",
+    "education",
+    "openai-compatible"
+  ],
+  "homepage": "https://cli.baryon.ai",
+  "bugs": {
+    "url": "https://github.com/baryonlabs/cli.baryon.ai/issues",
+    "email": "support@baryon.ai"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/baryonlabs/cli.baryon.ai.git",
+    "directory": "packages/cli"
+  },
+  "author": "Baryon Labs <support@baryon.ai> (https://baryon.ai)",
+  "license": "SEE LICENSE IN LICENSE",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/api.js

@@ -0,0 +1,61 @@
+// Minimal baryon.ai (OpenAI-compatible) helpers: model discovery + reachability.
+import { DEFAULT_MODELS } from "./constants.js";
+
+function joinUrl(base, suffix) {
+  return base.replace(/\/+$/, "") + suffix;
+}
+
+/**
+ * Fetch the institution's model catalog from `${baseUrl}/models`.
+ * Returns pi-shaped model entries, or null when discovery fails
+ * (offline / endpoint without a /models route).
+ */
+export async function discoverModels(baseUrl, apiKey, { timeoutMs = 8000 } = {}) {
+  const ctrl = new AbortController();
+  const t = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    const res = await fetch(joinUrl(baseUrl, "/models"), {
+      headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
+      signal: ctrl.signal,
+    });
+    if (!res.ok) return null;
+    const payload = await res.json();
+    const list = Array.isArray(payload?.data)
+      ? payload.data
+      : Array.isArray(payload)
+        ? payload
+        : null;
+    if (!list || !list.length) return null;
+    return list.map((m) => ({
+      id: m.id,
+      name: m.name || m.id,
+      reasoning: Boolean(m.reasoning),
+      input: Array.isArray(m.input) ? m.input : ["text"],
+      contextWindow: m.context_window || m.contextWindow || 128000,
+      maxTokens: m.max_tokens || m.maxTokens || 8192,
+    }));
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(t);
+  }
+}
+
+/** Lightweight reachability probe used by `baryon doctor`. */
+export async function ping(baseUrl, apiKey, { timeoutMs = 6000 } = {}) {
+  const ctrl = new AbortController();
+  const t = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    const res = await fetch(joinUrl(baseUrl, "/models"), {
+      headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
+      signal: ctrl.signal,
+    });
+    return { ok: res.ok, status: res.status };
+  } catch (e) {
+    return { ok: false, status: 0, error: e?.message || "network error" };
+  } finally {
+    clearTimeout(t);
+  }
+}
+
+export { DEFAULT_MODELS };

package/src/commands.js

@@ -0,0 +1,211 @@
+// Built-in baryon subcommands. Anything not matched here is passed to pi.
+import { spawn } from "node:child_process";
+import { discoverModels, ping } from "./api.js";
+import {
+  hasConfig,
+  loadConfig,
+  piProviderConfigured,
+  saveConfig,
+  syncPiModels,
+  BARYON_CONFIG,
+  PI_MODELS_JSON,
+} from "./config.js";
+import {
+  DEFAULT_BASE_URL,
+  DEFAULT_MODELS,
+  HOMEPAGE,
+  PI_PACKAGE,
+  PROVIDER,
+  SUPPORT_EMAIL,
+} from "./constants.js";
+import { runPi, resolvePiEntry } from "./pi.js";
+import { banner, c, info, log, ok, err, warn, prompt, promptHidden, sym } from "./ui.js";
+
+/** Parse `--flag value` / `--flag=value` pairs out of argv. */
+function parseFlags(args) {
+  const out = {};
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a.startsWith("--")) {
+      const eq = a.indexOf("=");
+      if (eq !== -1) out[a.slice(2, eq)] = a.slice(eq + 1);
+      else if (args[i + 1] && !args[i + 1].startsWith("-"))
+        out[a.slice(2)] = args[++i];
+      else out[a.slice(2)] = true;
+    }
+  }
+  return out;
+}
+
+export async function setup(args) {
+  const flags = parseFlags(args);
+  banner();
+  log(c.bold("  baryon.ai 연결 설정\n"));
+
+  const existing = loadConfig();
+  const baseUrl = flags["base-url"] || existing.baseUrl || DEFAULT_BASE_URL;
+
+  let apiKey = flags.key || flags["api-key"] || process.env.BARYON_API_KEY || "";
+  if (!apiKey) {
+    apiKey = await promptHidden(`  ${sym.info} baryon.ai API key: `);
+  }
+  if (!apiKey) {
+    warn("API 키 없이 저장합니다. 나중에 `baryon setup --key <KEY>` 로 추가하세요.");
+  }
+
+  saveConfig({ apiKey, baseUrl });
+  ok(`config 저장 → ${c.dim(BARYON_CONFIG)}`);
+
+  // Try live model discovery; fall back to defaults offline.
+  let models = null;
+  if (apiKey) {
+    info("모델 목록을 조회하는 중…");
+    models = await discoverModels(baseUrl, apiKey);
+  }
+  if (models) {
+    ok(`${models.length}개 모델 발견 (${c.lime(models.map((m) => m.id).slice(0, 4).join(", "))}${models.length > 4 ? "…" : ""})`);
+  } else {
+    models = DEFAULT_MODELS;
+    warn(`모델 자동 조회 실패 — 기본 모델 ${models.length}개로 구성 (오프라인/폐쇄망 정상)`);
+  }
+
+  saveConfig({ defaultModel: models[0].id });
+  const file = syncPiModels({ baseUrl, models });
+  ok(`pi 프로바이더 ${c.lime(PROVIDER)} 구성 → ${c.dim(file)}`);
+
+  log(`\n  ${sym.ok} 준비 완료. ${c.lime("baryon")} 으로 시작하세요.\n`);
+  return 0;
+}
+
+export async function doctor() {
+  banner();
+  log(c.bold("  진단 (baryon doctor)\n"));
+  let problems = 0;
+
+  // node
+  const major = Number(process.versions.node.split(".")[0]);
+  if (major >= 22) ok(`Node.js ${process.version}`);
+  else {
+    err(`Node.js ${process.version} — 22 이상 필요`);
+    problems++;
+  }
+
+  // pi installed?
+  const entry = resolvePiEntry();
+  if (entry) ok(`${PI_PACKAGE} 설치됨`);
+  else {
+    err(`${PI_PACKAGE} 미설치 — npm install -g @baryonlabs/cli`);
+    problems++;
+  }
+
+  // config?
+  if (hasConfig()) ok(`config 존재 → ${c.dim(BARYON_CONFIG)}`);
+  else {
+    warn("config 없음 — `baryon setup` 실행 필요");
+    problems++;
+  }
+
+  const cfg = loadConfig();
+  if (cfg.apiKey) ok(`API 키 설정됨 (${cfg.apiKey.slice(0, 4)}${"•".repeat(6)})`);
+  else warn("API 키 없음");
+
+  // pi provider registered?
+  if (piProviderConfigured()) ok(`pi 프로바이더 ${c.lime(PROVIDER)} 등록됨 → ${c.dim(PI_MODELS_JSON)}`);
+  else {
+    warn("pi 프로바이더 미등록 — `baryon setup` 실행");
+    problems++;
+  }
+
+  // connectivity
+  info(`연결 확인 중 → ${c.dim(cfg.baseUrl)}`);
+  const r = await ping(cfg.baseUrl, cfg.apiKey);
+  if (r.ok) ok(`baryon.ai 연결 정상 (HTTP ${r.status})`);
+  else if (r.status) warn(`엔드포인트 응답 HTTP ${r.status} — 키/권한 확인`);
+  else warn(`연결 불가 (${r.error}) — 오프라인이면 로컬 LLM 사용 가능`);
+
+  log(
+    problems === 0
+      ? `\n  ${sym.ok} ${c.teal("모든 점검 통과")}\n`
+      : `\n  ${sym.warn} ${c.yellow(`${problems}건 확인 필요`)}\n`,
+  );
+  return problems === 0 ? 0 : 1;
+}
+
+export async function models(args) {
+  const cfg = loadConfig();
+  // Delegate to pi's own --list-models so output matches the real catalog.
+  return runPi(["--list-models", ...args], cfg, { injectTargeting: false });
+}
+
+export async function configCmd(args) {
+  const flags = parseFlags(args);
+  if (flags.key || flags["api-key"] || flags["base-url"] || flags.model) {
+    const patch = {};
+    if (flags.key || flags["api-key"]) patch.apiKey = flags.key || flags["api-key"];
+    if (flags["base-url"]) patch.baseUrl = flags["base-url"];
+    if (flags.model) patch.defaultModel = flags.model;
+    saveConfig(patch);
+    ok("config 업데이트됨");
+    return 0;
+  }
+  const cfg = loadConfig();
+  banner();
+  log(c.bold("  현재 설정\n"));
+  info(`base URL    ${c.lime(cfg.baseUrl)}`);
+  info(`default     ${c.lime(cfg.defaultModel)}`);
+  info(`API key     ${cfg.apiKey ? cfg.apiKey.slice(0, 4) + "•".repeat(6) : c.dim("(없음)")}`);
+  info(`config 파일  ${c.dim(BARYON_CONFIG)}`);
+  info(`pi models   ${c.dim(PI_MODELS_JSON)}`);
+  log("");
+  return 0;
+}
+
+export function update() {
+  return new Promise((resolve) => {
+    log(`  ${sym.info} 업데이트: ${c.lime(`npm install -g @baryonlabs/cli ${PI_PACKAGE}`)}\n`);
+    const child = spawn(
+      "npm",
+      ["install", "-g", "@baryonlabs/cli", PI_PACKAGE],
+      { stdio: "inherit", shell: process.platform === "win32" },
+    );
+    child.on("exit", (code) => resolve(code ?? 0));
+    child.on("error", () => {
+      err("npm 실행 실패 — 수동으로 위 명령을 실행하세요.");
+      resolve(1);
+    });
+  });
+}
+
+export function help() {
+  banner();
+  log(`${c.bold("USAGE")}
+  ${c.lime("baryon")} ${c.dim("[options] [@files...] [messages...]")}     코딩 에이전트 시작 (baryon.ai 기본)
+
+${c.bold("COMMANDS")}
+  ${c.lime("baryon setup")}            baryon.ai API 키 등록 + pi 프로바이더 구성
+  ${c.lime("baryon config")}           현재 설정 보기 ${c.dim("(--key/--base-url/--model 로 변경)")}
+  ${c.lime("baryon models")}           사용 가능한 모델 목록
+  ${c.lime("baryon doctor")}           설치·연결 진단
+  ${c.lime("baryon update")}           CLI + pi 에이전트 업데이트
+  ${c.lime("baryon help")}             이 도움말
+
+${c.bold("EXAMPLES")}
+  ${c.dim("$")} baryon                              ${c.dim("# 대화형 시작")}
+  ${c.dim("$")} baryon -p "CSV 분석해 차트 만들어줘"   ${c.dim("# 단발 실행")}
+  ${c.dim("$")} baryon --provider openai            ${c.dim("# 다른 모델로 전환·비교")}
+  ${c.dim("$")} baryon --list-models                ${c.dim("# pi 패스스루")}
+
+${c.dim(`그 외 모든 옵션은 pi 에이전트로 그대로 전달됩니다.`)}
+${c.dim(`문서: ${HOMEPAGE} · 문의: ${SUPPORT_EMAIL}`)}
+`);
+  return 0;
+}
+
+/** Quiet first-run hint shown by postinstall (never fails the install). */
+export function welcome() {
+  if (!process.stdout.isTTY) return 0;
+  log(`\n${c.lime("✔")} ${c.bold("@baryonlabs/cli")} 설치 완료`);
+  log(`  ${c.dim("다음 단계:")} ${c.lime("baryon setup")} ${c.dim("→")} ${c.lime("baryon")}`);
+  log(`  ${c.dim(HOMEPAGE)}\n`);
+  return 0;
+}

package/src/config.js

@@ -0,0 +1,86 @@
+// Reads/writes Baryon config and merges a `baryon` provider into pi's
+// ~/.pi/agent/models.json without clobbering the user's other providers.
+import fs from "node:fs";
+import path from "node:path";
+import {
+  API_KEY_ENV,
+  BARYON_CONFIG,
+  BARYON_DIR,
+  DEFAULT_BASE_URL,
+  DEFAULT_MODELS,
+  PI_AGENT_DIR,
+  PI_MODELS_JSON,
+  PROVIDER,
+} from "./constants.js";
+
+function readJson(file, fallback) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+
+function writeJson(file, data) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(data, null, 2) + "\n");
+}
+
+/** Baryon config: { apiKey, baseUrl, defaultModel } */
+export function loadConfig() {
+  const cfg = readJson(BARYON_CONFIG, {});
+  return {
+    apiKey: process.env[API_KEY_ENV] || cfg.apiKey || "",
+    baseUrl: process.env.BARYON_BASE_URL || cfg.baseUrl || DEFAULT_BASE_URL,
+    defaultModel: cfg.defaultModel || DEFAULT_MODELS[0].id,
+  };
+}
+
+export function saveConfig(patch) {
+  const current = readJson(BARYON_CONFIG, {});
+  const next = { ...current, ...patch };
+  fs.mkdirSync(BARYON_DIR, { recursive: true, mode: 0o700 });
+  writeJson(BARYON_CONFIG, next);
+  try {
+    fs.chmodSync(BARYON_CONFIG, 0o600);
+  } catch {
+    /* best effort on non-POSIX */
+  }
+  return next;
+}
+
+export function hasConfig() {
+  return fs.existsSync(BARYON_CONFIG);
+}
+
+/**
+ * Merge the baryon provider into pi's models.json. Preserves every other
+ * provider already present. apiKey is stored as the `$BARYON_API_KEY`
+ * interpolation token (never the literal key) so the key lives only in
+ * ~/.baryon/config.json + the process env.
+ */
+export function syncPiModels({ baseUrl, models }) {
+  const root = readJson(PI_MODELS_JSON, {});
+  if (!root.providers || typeof root.providers !== "object") root.providers = {};
+
+  root.providers[PROVIDER] = {
+    name: "Baryon (baryon.ai)",
+    baseUrl: baseUrl || DEFAULT_BASE_URL,
+    api: "openai-completions",
+    apiKey: `$${API_KEY_ENV}`,
+    authHeader: true,
+    models:
+      Array.isArray(models) && models.length ? models : DEFAULT_MODELS,
+  };
+
+  fs.mkdirSync(PI_AGENT_DIR, { recursive: true });
+  writeJson(PI_MODELS_JSON, root);
+  return PI_MODELS_JSON;
+}
+
+export function piProviderConfigured() {
+  const root = readJson(PI_MODELS_JSON, {});
+  return Boolean(root?.providers?.[PROVIDER]);
+}
+
+export { PI_MODELS_JSON, BARYON_CONFIG };

package/src/constants.js

@@ -0,0 +1,51 @@
+import os from "node:os";
+import path from "node:path";
+
+/** Provider id registered inside pi's models.json */
+export const PROVIDER = "baryon";
+
+/** Default OpenAI-compatible endpoint for baryon.ai. Override with BARYON_BASE_URL. */
+export const DEFAULT_BASE_URL =
+  process.env.BARYON_BASE_URL || "https://api.baryon.ai/v1";
+
+/** Env var pi resolves at request time (apiKey: "$BARYON_API_KEY"). */
+export const API_KEY_ENV = "BARYON_API_KEY";
+
+/** Underlying coding agent package + binary. */
+export const PI_PACKAGE = "@earendil-works/pi-coding-agent";
+export const PI_BIN = "pi";
+
+/** Baryon-side config (api key, base url, default model). */
+export const BARYON_DIR = path.join(os.homedir(), ".baryon");
+export const BARYON_CONFIG = path.join(BARYON_DIR, "config.json");
+
+/** pi's custom-provider/model registry. */
+export const PI_AGENT_DIR = path.join(os.homedir(), ".pi", "agent");
+export const PI_MODELS_JSON = path.join(PI_AGENT_DIR, "models.json");
+
+/**
+ * Fallback model catalog used when /models discovery is unavailable
+ * (e.g. offline setup). Institutions adjust these to match their plan.
+ * `context` / `max` are conservative defaults; pi tolerates overrides.
+ */
+export const DEFAULT_MODELS = [
+  {
+    id: "baryon-coder",
+    name: "Baryon Coder",
+    reasoning: true,
+    input: ["text", "image"],
+    contextWindow: 128000,
+    maxTokens: 16384,
+  },
+  {
+    id: "baryon-coder-mini",
+    name: "Baryon Coder Mini",
+    reasoning: false,
+    input: ["text"],
+    contextWindow: 128000,
+    maxTokens: 8192,
+  },
+];
+
+export const HOMEPAGE = "https://cli.baryon.ai";
+export const SUPPORT_EMAIL = "support@baryon.ai";

package/src/index.js

@@ -0,0 +1,44 @@
+// Programmatic API for @baryonlabs/cli.
+//
+//   import { configure, run, discover } from "@baryonlabs/cli";
+//
+// Lets host apps register the baryon provider and launch pi without shelling
+// out to the `baryon` binary.
+import { discoverModels, ping } from "./api.js";
+import {
+  loadConfig,
+  saveConfig,
+  syncPiModels,
+  piProviderConfigured,
+} from "./config.js";
+import { DEFAULT_BASE_URL, DEFAULT_MODELS, PROVIDER } from "./constants.js";
+import { runPi, resolvePiEntry } from "./pi.js";
+
+/**
+ * Configure the baryon provider: persist key/baseUrl, discover (or default)
+ * models, and write pi's models.json. Returns the resolved config + model ids.
+ */
+export async function configure({ apiKey, baseUrl = DEFAULT_BASE_URL } = {}) {
+  if (apiKey) saveConfig({ apiKey, baseUrl });
+  const models = (apiKey && (await discoverModels(baseUrl, apiKey))) || DEFAULT_MODELS;
+  saveConfig({ defaultModel: models[0].id });
+  syncPiModels({ baseUrl, models });
+  return { baseUrl, models: models.map((m) => m.id), defaultModel: models[0].id };
+}
+
+/** Launch pi with the current baryon config. Resolves to the exit code. */
+export function run(args = []) {
+  return runPi(args, loadConfig());
+}
+
+export {
+  loadConfig,
+  saveConfig,
+  discoverModels as discover,
+  ping,
+  piProviderConfigured,
+  resolvePiEntry,
+  PROVIDER,
+  DEFAULT_BASE_URL,
+  DEFAULT_MODELS,
+};

package/src/pi.js

@@ -0,0 +1,115 @@
+// Resolves the bundled pi binary and launches it with the baryon provider
+// pre-selected and BARYON_API_KEY injected into the environment.
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import fs from "node:fs";
+import path from "node:path";
+import {
+  API_KEY_ENV,
+  PI_BIN,
+  PI_PACKAGE,
+  PROVIDER,
+} from "./constants.js";
+
+const require = createRequire(import.meta.url);
+
+/** Find the package root (dir holding the matching package.json) above a file. */
+function findPackageRoot(startFile, name) {
+  let dir = path.dirname(startFile);
+  for (let i = 0; i < 8; i++) {
+    const pj = path.join(dir, "package.json");
+    if (fs.existsSync(pj)) {
+      try {
+        if (JSON.parse(fs.readFileSync(pj, "utf8")).name === name) return dir;
+      } catch {
+        /* keep walking */
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+/**
+ * Absolute path to pi's entry script (dist/cli.js), or null if not installed.
+ * pi's `exports` map hides ./package.json, so we resolve its main entry and
+ * walk up to the package root to read `bin.pi`.
+ */
+export function resolvePiEntry() {
+  try {
+    // pi's "." export only defines `import` (ESM), so the CJS require.resolve
+    // fails with ERR_PACKAGE_PATH_NOT_EXPORTED. Prefer the ESM resolver.
+    let main;
+    try {
+      main = fileURLToPath(import.meta.resolve(PI_PACKAGE));
+    } catch {
+      main = require.resolve(PI_PACKAGE);
+    }
+    const root = findPackageRoot(main, PI_PACKAGE) || path.dirname(main);
+    const pkg = JSON.parse(
+      fs.readFileSync(path.join(root, "package.json"), "utf8"),
+    );
+    const rel =
+      typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.[PI_BIN] || pkg.bin?.pi;
+    if (!rel) return null;
+    return path.join(root, rel);
+  } catch {
+    return null;
+  }
+}
+
+const TARGETING_FLAGS = ["--provider", "--model", "--api-key"];
+
+/** True if the user already chose a provider/model/key themselves. */
+function userOverridesTargeting(args) {
+  return args.some((a) => TARGETING_FLAGS.includes(a));
+}
+
+/**
+ * Launch pi. By default injects `--provider baryon` (and the configured
+ * default model) plus the API key env, while passing every other arg through
+ * untouched. If the user supplies their own --provider/--model/--api-key we
+ * leave targeting entirely to them (so model comparison still works).
+ *
+ * @returns {Promise<number>} pi's exit code
+ */
+export function runPi(args, config, { injectTargeting = true } = {}) {
+  const entry = resolvePiEntry();
+  if (!entry) {
+    return Promise.reject(
+      new Error(
+        `${PI_PACKAGE} is not installed. Run: npm install -g @baryonlabs/cli`,
+      ),
+    );
+  }
+
+  const finalArgs = [...args];
+  if (injectTargeting && !userOverridesTargeting(args)) {
+    finalArgs.unshift("--provider", PROVIDER);
+    if (config.defaultModel) {
+      finalArgs.unshift("--model", `${PROVIDER}/${config.defaultModel}`);
+    }
+  }
+
+  const env = { ...process.env };
+  if (config.apiKey) env[API_KEY_ENV] = config.apiKey;
+  if (config.baseUrl) env.BARYON_BASE_URL = config.baseUrl;
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [entry, ...finalArgs], {
+      stdio: "inherit",
+      env,
+    });
+    child.on("error", reject);
+    child.on("exit", (code, signal) => {
+      if (signal) {
+        process.kill(process.pid, signal);
+        return;
+      }
+      resolve(code ?? 0);
+    });
+  });
+}

package/src/ui.js

@@ -0,0 +1,96 @@
+// Tiny zero-dependency ANSI helpers + prompts.
+import readline from "node:readline";
+
+const useColor =
+  process.stdout.isTTY && !process.env.NO_COLOR && process.env.TERM !== "dumb";
+
+const wrap = (open, close) => (s) =>
+  useColor ? `\x1b[${open}m${s}\x1b[${close}m` : String(s);
+
+export const c = {
+  lime: wrap("38;5;191", "39"),
+  teal: wrap("38;5;43", "39"),
+  red: wrap("38;5;203", "39"),
+  yellow: wrap("38;5;221", "39"),
+  dim: wrap("2", "22"),
+  bold: wrap("1", "22"),
+  gray: wrap("38;5;245", "39"),
+};
+
+export const sym = {
+  ok: c.teal("✔"),
+  err: c.red("✖"),
+  warn: c.yellow("▲"),
+  info: c.lime("›"),
+  arrow: c.lime("→"),
+};
+
+export const log = (...a) => console.log(...a);
+export const ok = (m) => log(`  ${sym.ok} ${m}`);
+export const err = (m) => log(`  ${sym.err} ${c.red(m)}`);
+export const warn = (m) => log(`  ${sym.warn} ${c.yellow(m)}`);
+export const info = (m) => log(`  ${sym.info} ${m}`);
+
+export function banner() {
+  const art = [
+    "   ___                          ___ _    ___",
+    "  / _ )___ _______ _____  ___  / __| |  |_ _|",
+    " / _  / _ `/ __/ // / _ \\/ _ \\ (__| |__ | |",
+    "/____/\\_,_/_/  \\_, /\\___/_//_/\\___|____|___|",
+    "              /___/",
+  ].join("\n");
+  log(c.lime(c.bold(art)));
+  log(c.dim("  AI coding & learning agent · baryon.ai\n"));
+}
+
+/** Hidden-input prompt (for API keys). Falls back to visible if no TTY. */
+export function promptHidden(question) {
+  return new Promise((resolve) => {
+    if (!process.stdin.isTTY) {
+      // non-interactive: read one line from stdin
+      const rl = readline.createInterface({ input: process.stdin });
+      rl.question(question, (a) => {
+        rl.close();
+        resolve(a.trim());
+      });
+      return;
+    }
+    const stdin = process.stdin;
+    process.stdout.write(question);
+    stdin.setRawMode(true);
+    stdin.resume();
+    let buf = "";
+    const onData = (ch) => {
+      const s = ch.toString("utf8");
+      if (s === "\r" || s === "\n") {
+        stdin.setRawMode(false);
+        stdin.pause();
+        stdin.removeListener("data", onData);
+        process.stdout.write("\n");
+        resolve(buf.trim());
+      } else if (s === "") {
+        // Ctrl+C
+        process.stdout.write("\n");
+        process.exit(130);
+      } else if (s === "" || s === "\b") {
+        buf = buf.slice(0, -1);
+      } else {
+        buf += s;
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+
+export function prompt(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    rl.question(question, (a) => {
+      rl.close();
+      resolve(a.trim());
+    });
+  });
+}