@xevy/cli 0.1.1 → 0.1.3

package/README.md

@@ -1,71 +1,50 @@
 # @xevy/cli
 
-The **`xevy`** command — one step to get Xevy working in your AI agent.
+The **`xevy`** command — set up and launch the [pi](https://github.com/badlogic/pi-mono) agent with Xevy.
 
 ```bash
-npx @xevy/cli setup
+npx @xevy/cli setup   # one-time: install pi + the Xevy extension + your API key
+npx @xevy/cli         # open pi with the Xevy extension loaded
 ```
 
-`xevy setup` installs the **Xevy SDLC agent skills** and the **Xevy MCP server**
-into your user-global agent config, for [Cursor, Claude Code, and 50+ other
-agents](https://github.com/vercel-labs/skills#supported-agents).
+## `xevy setup`
 
-## No API key — OAuth like any MCP
+1. Installs the **pi agent** if it isn't already on your PATH.
+2. Downloads the Xevy pi extension (`xevy.ts`) into **`~/.xevy/extensions/`**.
+3. Asks for your **API key** and prints a **direct link to the API-keys tab** so
+   you can generate one in a couple of clicks, then stores it in
+   `~/.config/xevy/credentials` (mode `600`, never printed).
 
-The Xevy MCP server signs in with **OAuth**, completed inside your agent the
-first time it connects. There is no API key to find in a dashboard, paste, or
-store on disk.
+The API-keys link opens **Settings → Profile → API keys** directly:
+`https://xevy.ai/settings?section=profile&tab=api`.
 
-- **Cursor:** Settings → MCP → `xevy` → connect
-- **Claude Code:** browser sign-in on the first MCP call
+## `xevy`
 
-## What it does (and doesn't)
-
-- ✅ Installs skills globally (`~/.cursor/skills`, `~/.claude/skills`, `~/.agents/skills`, …)
-- ✅ Writes the MCP server to your agent's **global** config
-- ❌ No per-repo files, no project detection, no repo linking
-
-To link a specific repository to a Xevy project later, run the bundled
-`xevy-setup` skill from inside your agent (it uses the MCP tools over OAuth).
-
-## Install permanently
+Opens pi, loading every `*.ts` extension in `~/.xevy/extensions` (`pi -e …`).
+Any extra arguments are forwarded to pi:
 
 ```bash
-npm i -g @xevy/cli
-xevy setup
+xevy                       # interactive pi session with Xevy
+xevy "summarise this repo" # forwards the prompt to pi
 ```
 
+## `xevy pi` (alternative)
+
+Installs the split **model + MCP** extensions (`xevy-model.ts`, `xevy-mcp.ts`)
+into pi's own extensions dir and authenticates over **OAuth** (`/login xevy`) —
+no API key. Use this instead of `setup` if you prefer OAuth and the hosted
+`xevy/*` models + MCP tool bridge.
+
 ## Options
 
 ```
-xevy setup [options]
-
-  -a, --agent <name>   Target agent (repeatable). Default: cursor, claude-code
-      --base <url>     Xevy host (default: XEVY_BASE or https://xevy.ai)
-      --skills-only    Install skills only (skip MCP)
-      --mcp-only       Configure the OAuth MCP server only (skip skills)
-      --copy           Copy skill files instead of symlinking
-  -v, --version        Print the CLI version
-  -h, --help           Show help
+      --base <url>   Xevy host (default: XEVY_BASE or https://xevy.ai)
+  -v, --version      Print the CLI version
+  -h, --help         Show help
 ```
 
-### Examples
-
 ```bash
-npx @xevy/cli setup                                   # skills + MCP, global
-npx @xevy/cli setup -a cursor                         # Cursor only
-npx @xevy/cli setup --mcp-only                        # just the OAuth MCP
-XEVY_BASE=https://xevy.vyte.dev npx @xevy/cli setup   # non-default host
+XEVY_BASE=https://xevy.vyte.dev npx @xevy/cli setup
 ```
 
-## How it works
-
-Under the hood `xevy setup` drives two well-known primitives:
-
-- [`npx skills`](https://github.com/vercel-labs/skills) — installs the skills
-- [`npx add-mcp`](https://github.com/neondatabase/add-mcp) — writes the MCP config
-
-Skills are sourced from the pinned [`@xevy/skills`](https://www.npmjs.com/package/@xevy/skills)
-dependency, so this CLI stays in step with the published skills.
-
 Docs: <https://xevy.ai/docs/mcp>

package/bin/xevy.mjs

@@ -2,47 +2,57 @@
 /**
  * @xevy/cli — the `xevy` command.
  *
- * `xevy setup` installs the Xevy SDLC agent skills and the Xevy MCP server
- * globally, for Cursor / Claude Code / 50+ agents. The MCP server authenticates
- * via OAuth (completed inside the agent on first connect) — there is NO API key
- * to find, paste, or store. No repo/project detection or linking happens here.
+ *   xevy setup   Install the pi agent (if missing), download the Xevy pi
+ *                extension into ~/.xevy/extensions, and store your API key.
+ *   xevy         Open pi with the Xevy extensions from ~/.xevy/extensions.
+ *   xevy pi      (alt) Install the split model + MCP extensions into pi's own
+ *                extensions dir, authenticated via OAuth.
  *
- * Under the hood it drives the same primitives the Xevy docs recommend:
- *   • `npx skills add <dir>`  — copies/symlinks the skills into agent scopes
- *   • `npx add-mcp <url>`     — writes the agent MCP config (OAuth on connect)
- * Skills are sourced from the pinned `@xevy/skills` dependency, so this CLI
- * stays in step with the published skills without duplicating them.
- *
- * Usage:
- *   npx @xevy/cli setup            Install skills + MCP globally (OAuth)
- *   npx @xevy/cli setup -a cursor  Only a specific agent (repeatable)
- *   npx @xevy/cli setup --mcp-only Configure the OAuth MCP server only
- *   npx @xevy/cli --version
+ * `xevy setup` is the default flow: it fetches `xevy.ts` from the server and
+ * asks for an API key (with a direct link to the exact page to generate one),
+ * stored in ~/.config/xevy/credentials. Then `xevy` launches pi with it.
  */
 import { spawnSync } from "node:child_process";
-import { createRequire } from "node:module";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import readline from "node:readline";
 import { fileURLToPath } from "node:url";
 
-const require = createRequire(import.meta.url);
 const here = path.dirname(fileURLToPath(import.meta.url));
 const pkgRoot = path.resolve(here, "..");
 
 const DEFAULT_BASE = "https://xevy.ai";
-const DEFAULT_AGENTS = ["cursor", "claude-code"];
 const isWindows = process.platform === "win32";
 
 const PI_PACKAGE = "@mariozechner/pi-coding-agent";
+const PI_BIN = isWindows ? "pi.cmd" : "pi";
+
+// Where `xevy setup` installs the extension and `xevy` loads it from.
+const XEVY_EXTENSIONS_DIR = path.join(os.homedir(), ".xevy", "extensions");
+const XEVY_EXTENSION_FILE = "xevy.ts";
+const API_KEY_PREFIX = "xevy_pk_";
+
+// Credentials file the xevy.ts extension reads (baseUrl + token).
+const CREDENTIALS_DIR = path.join(
+  process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"),
+  "xevy",
+);
+const CREDENTIALS_FILE = path.join(CREDENTIALS_DIR, "credentials");
+
+// `xevy pi` (alt flow) installs these into pi's own extensions dir over OAuth.
 const PI_EXTENSION_DIR = path.join(os.homedir(), ".pi", "agent", "extensions");
-// pi extensions installed by `xevy pi` — file name + a marker string used to
-// sanity-check the download isn't SPA HTML (wrong --base).
 const PI_EXTENSIONS = [
   { file: "xevy-model.ts", marker: "xevyModelExtension" },
   { file: "xevy-mcp.ts", marker: "xevyMcpExtension" },
 ];
 
+function apiKeysUrl(base) {
+  // Direct link to the API keys tab (Profile → API keys), reachable without a
+  // project via the root Settings app.
+  return `${base}/settings?section=profile&tab=api`;
+}
+
 function readCliVersion() {
   try {
     const pkg = JSON.parse(fs.readFileSync(path.join(pkgRoot, "package.json"), "utf-8"));
@@ -58,144 +68,65 @@ function die(msg) {
 }
 
 function usage() {
-  console.log(`Xevy CLI — install Xevy agent skills + OAuth MCP.
+  console.log(`Xevy CLI
 
-  xevy setup [options]        Install skills + MCP globally (OAuth, no API key)
-  xevy pi [options]           Install the pi agent (if missing) + the xevy-model.ts extension
+  xevy                   Open pi with the Xevy extensions in ~/.xevy/extensions
+  xevy setup [--base u]  Install pi (if missing) + the Xevy pi extension, store your API key
+  xevy pi [--base u]     (alt) Install the split model + MCP extensions over OAuth
 
 Options:
-  -a, --agent <name>          Target agent (repeatable). Default: ${DEFAULT_AGENTS.join(", ")}
-      --base <url>            Xevy host (default: XEVY_BASE or ${DEFAULT_BASE})
-      --skills-only           Install skills only (skip MCP)
-      --mcp-only              Configure the OAuth MCP server only (skip skills)
-      --copy                  Copy skill files instead of symlinking
-  -v, --version              Print the CLI version
-  -h, --help                 Show this help
-
-Notes:
-  • Everything installs to your user-global scope — no per-repo files, no
-    project detection or linking.
-  • The MCP server signs in with OAuth from inside your agent on first
-    connect. There is no API key to paste.
+      --base <url>       Xevy host (default: XEVY_BASE or ${DEFAULT_BASE})
+  -v, --version          Print the CLI version
+  -h, --help             Show this help
 
 Examples:
   npx @xevy/cli setup
-  npx @xevy/cli setup -a cursor
-  npx @xevy/cli pi
+  npx @xevy/cli
   XEVY_BASE=https://xevy.vyte.dev npx @xevy/cli setup`);
 }
 
 function parseArgv(argv) {
-  const opts = {
-    command: "setup",
-    agents: [],
-    base: process.env.XEVY_BASE?.replace(/\/$/, "") || DEFAULT_BASE,
-    skillsOnly: false,
-    mcpOnly: false,
-    copy: false,
-  };
-
+  const base = process.env.XEVY_BASE?.replace(/\/$/, "") || DEFAULT_BASE;
   const args = [...argv];
-  if (args.length > 0 && !args[0].startsWith("-")) {
-    const cmd = args.shift();
-    if (cmd === "setup" || cmd === "pi") {
-      opts.command = cmd;
-    } else if (cmd === "help") {
-      opts.command = "help";
-      return opts;
-    } else {
-      die(`Unknown command: ${cmd}. Try \`xevy --help\`.`);
-    }
-  }
 
-  while (args.length > 0) {
-    const a = args.shift();
-    if (a === "-h" || a === "--help") return { ...opts, command: "help" };
-    if (a === "-v" || a === "--version") return { ...opts, command: "version" };
-    if (a === "-a" || a === "--agent") {
-      const v = args.shift();
-      if (!v) die("Missing value for --agent");
-      opts.agents.push(v);
-      continue;
-    }
-    if (a === "--base") {
-      const v = args.shift();
-      if (!v) die("Missing value for --base");
-      opts.base = v.replace(/\/$/, "");
-      continue;
+  if (args.length === 0) return { command: "open", base, piArgs: [] };
+
+  const first = args[0];
+  if (first === "-h" || first === "--help" || first === "help") return { command: "help", base };
+  if (first === "-v" || first === "--version") return { command: "version", base };
+
+  if (first === "setup" || first === "pi") {
+    args.shift();
+    const opts = { command: first, base, piArgs: [] };
+    while (args.length > 0) {
+      const a = args.shift();
+      if (a === "--base") {
+        const v = args.shift();
+        if (!v) die("Missing value for --base");
+        opts.base = v.replace(/\/$/, "");
+        continue;
+      }
+      die(`Unknown option for \`xevy ${first}\`: ${a}. Try \`xevy --help\`.`);
     }
-    if (a === "--skills-only") { opts.skillsOnly = true; continue; }
-    if (a === "--mcp-only") { opts.mcpOnly = true; continue; }
-    if (a === "--copy") { opts.copy = true; continue; }
-    die(`Unknown option: ${a}. Try \`xevy --help\`.`);
+    return opts;
   }
 
-  if (opts.skillsOnly && opts.mcpOnly) {
-    die("--skills-only and --mcp-only are mutually exclusive.");
-  }
-  if (opts.agents.length === 0) opts.agents = [...DEFAULT_AGENTS];
-  return opts;
-}
-
-function quoteArg(a) {
-  return /[\s"]/.test(a) ? `"${a.replace(/"/g, '\\"')}"` : a;
+  // Anything else → open pi, forwarding the args through.
+  return { command: "open", base, piArgs: args };
 }
 
 function run(cmd, args, { label } = {}) {
   const title = label || [cmd, ...args].join(" ");
   console.log(`→ ${title}`);
   const command = isWindows && cmd === "npx" ? "npx.cmd" : cmd;
-  const finalArgs = isWindows ? args.map(quoteArg) : args;
-  const r = spawnSync(command, finalArgs, { stdio: "inherit", shell: isWindows, env: process.env });
+  const r = spawnSync(command, args, { stdio: "inherit", shell: isWindows, env: process.env });
   if (r.error) die(r.error.message);
   if (r.status !== 0) die(`Command failed (${r.status}): ${title}`);
   return r;
 }
 
-/** Resolve the on-disk root of the pinned @xevy/skills dependency. */
-function resolveSkillsRoot() {
-  try {
-    return path.dirname(require.resolve("@xevy/skills/package.json"));
-  } catch {
-    die("Could not locate the bundled @xevy/skills package. Reinstall @xevy/cli and try again.");
-  }
-}
-
-function installSkills(opts) {
-  const skillsRoot = resolveSkillsRoot();
-  const args = ["--yes", "skills", "add", skillsRoot, "-g", "-y", "-s", "*"];
-  if (opts.copy) args.push("--copy");
-  for (const a of opts.agents) args.push("-a", a);
-  run("npx", args, { label: "npx skills add (Xevy skills, global)" });
-}
-
-function installMcp(opts) {
-  const mcpUrl = `${opts.base}/mcp`;
-  const args = ["--yes", "add-mcp", mcpUrl, "-n", "xevy", "-g", "-y"];
-  for (const a of opts.agents) args.push("-a", a);
-  run("npx", args, { label: `npx add-mcp ${mcpUrl} (OAuth, global)` });
-}
-
-function setup(opts) {
-  console.log("Setting up Xevy (global, OAuth — no API key)\n");
-
-  if (!opts.mcpOnly) installSkills(opts);
-  if (!opts.skillsOnly) installMcp(opts);
-
-  console.log("\n✓ Xevy setup complete.");
-  if (!opts.skillsOnly) {
-    console.log("  • Complete OAuth in your agent on first connect:");
-    console.log("      Cursor: Settings → MCP → xevy → connect");
-    console.log("      Claude Code: browser sign-in on first MCP call");
-  }
-  if (opts.base !== DEFAULT_BASE) {
-    console.log(`  • Host: ${opts.base} (set XEVY_BASE in your agent env too, then restart).`);
-  }
-  console.log(`  • Docs: ${opts.base}/docs/mcp`);
-}
-
 function hasPi() {
-  const r = spawnSync(isWindows ? "pi.cmd" : "pi", ["--version"], { stdio: "ignore", shell: isWindows });
+  const r = spawnSync(PI_BIN, ["--version"], { stdio: "ignore", shell: isWindows });
   return !r.error && r.status === 0;
 }
 
@@ -207,12 +138,12 @@ function ensurePi() {
   console.log(`→ pi agent not found — installing ${PI_PACKAGE} globally…`);
   run("npm", ["install", "-g", PI_PACKAGE], { label: `npm install -g ${PI_PACKAGE}` });
   if (!hasPi()) {
-    die("pi is still not on PATH after install. Ensure your npm global bin dir is on PATH, then re-run `xevy pi`.");
+    die("pi is still not on PATH after install. Ensure your npm global bin dir is on PATH, then re-run.");
   }
 }
 
-async function installExtension(opts, { file, marker }) {
-  const url = `${opts.base}/${file}`;
+async function downloadExtension(base, file, destDir, markers) {
+  const url = `${base}/${file}`;
   console.log(`→ Downloading ${url}`);
 
   let source;
@@ -225,14 +156,101 @@ async function installExtension(opts, { file, marker }) {
   }
 
   // Guard against a wrong --base returning the SPA HTML instead of the extension.
-  if (!source.includes(marker) || !source.includes("registerCommand")) {
+  if (!markers.every((m) => source.includes(m))) {
     die(`Downloaded ${url} does not look like the ${file} extension (wrong --base?).`);
   }
 
-  fs.mkdirSync(PI_EXTENSION_DIR, { recursive: true });
-  const dest = path.join(PI_EXTENSION_DIR, file);
+  fs.mkdirSync(destDir, { recursive: true });
+  const dest = path.join(destDir, file);
   fs.writeFileSync(dest, source, "utf-8");
   console.log(`✓ Installed ${dest}`);
+  return dest;
+}
+
+function promptLine(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(String(answer || "").trim());
+    });
+  });
+}
+
+function writeCredentials(base, token) {
+  fs.mkdirSync(CREDENTIALS_DIR, { recursive: true });
+  fs.writeFileSync(
+    CREDENTIALS_FILE,
+    `baseUrl=${base}\ntoken=${token}\nupdatedAt=${new Date().toISOString()}\n`,
+    { mode: 0o600 },
+  );
+  try {
+    fs.chmodSync(CREDENTIALS_FILE, 0o600);
+  } catch {
+    // best-effort on platforms without chmod
+  }
+}
+
+async function setup(opts) {
+  console.log("Setting up Xevy for pi\n");
+
+  // 1. Ensure pi is installed (installs it if missing).
+  ensurePi();
+
+  // 2. Extensions:
+  //    • xevy.ts       → ~/.xevy/extensions   (tools/workflow; loaded by `xevy`)
+  //    • xevy-model.ts → pi's GLOBAL extensions dir, so the xevy/* models are
+  //      available in EVERY pi session (plain `pi` too), not just via `xevy`.
+  await downloadExtension(opts.base, XEVY_EXTENSION_FILE, XEVY_EXTENSIONS_DIR, [
+    "EXTENSION_VERSION",
+    "registerCommand",
+  ]);
+  await downloadExtension(opts.base, "xevy-model.ts", PI_EXTENSION_DIR, [
+    "xevyModelExtension",
+    "registerCommand",
+  ]);
+
+  // 2. API key — with a direct link to the exact page to generate one.
+  console.log("\nGet your API key (this link opens the API keys tab directly):");
+  console.log(`  ${apiKeysUrl(opts.base)}`);
+  console.log("  Sign in if prompted, then click “Create API key” and copy it.\n");
+
+  const token = await promptLine(`Paste your Xevy API key (${API_KEY_PREFIX}…): `);
+  if (!token) die("API key is required. Re-run `xevy setup` when you have one.");
+  if (!token.startsWith(API_KEY_PREFIX)) {
+    die(`That doesn't look like a Xevy API key (expected '${API_KEY_PREFIX}…'). Not saved.`);
+  }
+  writeCredentials(opts.base, token);
+  console.log(`✓ API key stored at ${CREDENTIALS_FILE} (key not shown).`);
+
+  console.log("\n✓ Setup complete.");
+  console.log("  • Xevy models (xevy/auto, xevy/fast, …) are available in any pi session — no /login needed.");
+  console.log("  • Run `xevy` to open pi with the Xevy tools + models loaded.");
+  if (opts.base !== DEFAULT_BASE) console.log(`  • Host: ${opts.base}`);
+}
+
+function open(opts) {
+  if (!hasPi()) {
+    die("pi is not installed. Run `xevy setup` first.");
+  }
+  let files = [];
+  if (fs.existsSync(XEVY_EXTENSIONS_DIR)) {
+    files = fs
+      .readdirSync(XEVY_EXTENSIONS_DIR)
+      .filter((f) => f.endsWith(".ts"))
+      .map((f) => path.join(XEVY_EXTENSIONS_DIR, f));
+  }
+  if (files.length === 0) {
+    die(`No Xevy extensions in ${XEVY_EXTENSIONS_DIR}. Run \`xevy setup\` first.`);
+  }
+
+  const piArgs = [];
+  for (const f of files) piArgs.push("-e", f);
+  piArgs.push(...opts.piArgs);
+
+  const r = spawnSync(PI_BIN, piArgs, { stdio: "inherit", shell: isWindows, env: process.env });
+  if (r.error) die(r.error.message);
+  process.exit(r.status ?? 0);
 }
 
 async function piSetup(opts) {
@@ -240,7 +258,7 @@ async function piSetup(opts) {
 
   ensurePi();
   for (const ext of PI_EXTENSIONS) {
-    await installExtension(opts, ext);
+    await downloadExtension(opts.base, ext.file, PI_EXTENSION_DIR, [ext.marker, "registerCommand"]);
   }
 
   console.log("\n✓ pi + Xevy extensions ready.");
@@ -248,9 +266,7 @@ async function piSetup(opts) {
   console.log("  • Xevy models: xevy/auto, xevy/fast, xevy/advance, xevy/min, xevy/max, xevy/vision.");
   console.log("  • MCP tools bridge automatically on session start (or run /xevy-mcp).");
   console.log("  • If pi is already running, use /reload to load the extensions.");
-  if (opts.base !== DEFAULT_BASE) {
-    console.log(`  • Source host: ${opts.base}`);
-  }
+  if (opts.base !== DEFAULT_BASE) console.log(`  • Source host: ${opts.base}`);
 }
 
 async function main() {
@@ -260,6 +276,7 @@ async function main() {
   if (opts.command === "version") return console.log(readCliVersion());
   if (opts.command === "setup") return setup(opts);
   if (opts.command === "pi") return piSetup(opts);
+  if (opts.command === "open") return open(opts);
 }
 
 main().catch((error) => die(error instanceof Error ? error.message : String(error)));

package/package.json

@@ -1,17 +1,14 @@
 {
   "name": "@xevy/cli",
-  "version": "0.1.1",
-  "description": "Xevy CLI — one command (`xevy setup`) installs the Xevy SDLC agent skills and the OAuth MCP server globally for Cursor, Claude Code, and 50+ agents. No API key required.",
+  "version": "0.1.3",
+  "description": "Xevy CLI — `xevy setup` installs the pi agent + the Xevy pi extension and stores your API key; `xevy` opens pi with it.",
   "type": "module",
   "keywords": [
     "xevy",
     "cli",
     "setup",
-    "mcp",
-    "oauth",
-    "agent-skills",
-    "cursor",
-    "claude-code",
+    "pi",
+    "pi-agent",
     "sdlc"
   ],
   "homepage": "https://xevy.ai/docs/mcp",
@@ -26,9 +23,6 @@
   "engines": {
     "node": ">=18"
   },
-  "dependencies": {
-    "@xevy/skills": "^0.1.18"
-  },
   "publishConfig": {
     "access": "public"
   }