@eidentic/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1127 @@
+#!/usr/bin/env node
+import "./chunk-QGM4M3NI.js";
+
+// src/index.ts
+import { defineCommand, runMain } from "citty";
+import { consola } from "consola";
+import pc from "picocolors";
+import { createRequire } from "node:module";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { dirname as dirname2, join as join2 } from "node:path";
+import { existsSync as existsSync2 } from "node:fs";
+import { spawn } from "node:child_process";
+
+// src/commands.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync, appendFileSync, readdirSync, copyFileSync, statSync } from "node:fs";
+import { join, resolve, isAbsolute, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createJiti } from "jiti";
+import { createServer } from "@eidentic/server";
+var INIT_PROVIDERS = {
+  anthropic: {
+    package: "@ai-sdk/anthropic",
+    envVar: "ANTHROPIC_API_KEY",
+    importLine: 'import { anthropic } from "@ai-sdk/anthropic";',
+    modelId: "claude-sonnet-4-5",
+    providerFn: "anthropic",
+    models: ["claude-sonnet-4-5", "claude-opus-4-1", "claude-haiku-4-5"]
+  },
+  openai: {
+    package: "@ai-sdk/openai",
+    envVar: "OPENAI_API_KEY",
+    importLine: 'import { openai } from "@ai-sdk/openai";',
+    modelId: "gpt-4o",
+    providerFn: "openai",
+    models: ["gpt-4o", "gpt-4o-mini", "o4-mini"]
+  },
+  google: {
+    package: "@ai-sdk/google",
+    envVar: "GOOGLE_GENERATIVE_AI_API_KEY",
+    importLine: 'import { google } from "@ai-sdk/google";',
+    modelId: "gemini-2.5-pro",
+    providerFn: "google",
+    models: ["gemini-2.5-pro", "gemini-2.5-flash"]
+  },
+  deepseek: {
+    package: "@ai-sdk/deepseek",
+    envVar: "DEEPSEEK_API_KEY",
+    importLine: 'import { deepseek } from "@ai-sdk/deepseek";',
+    modelId: "deepseek-chat",
+    providerFn: "deepseek",
+    models: ["deepseek-chat", "deepseek-reasoner"]
+  },
+  mistral: {
+    package: "@ai-sdk/mistral",
+    envVar: "MISTRAL_API_KEY",
+    importLine: 'import { mistral } from "@ai-sdk/mistral";',
+    modelId: "mistral-large-latest",
+    providerFn: "mistral",
+    models: ["mistral-large-latest", "mistral-small-latest"]
+  }
+};
+function eidenticConfigTs(p, modelId) {
+  return `import { Agent, AIModel, SqliteStore, createTool, defaultPrices } from "eidentic";
+${p.importLine}
+import { z } from "zod";
+
+const store = new SqliteStore("./eidentic.sqlite");
+await store.migrate();
+
+// A tiny example tool \u2014 replace or extend with your own.
+const getTime = createTool({
+  id: "get_time",
+  description: "Get the current server time as an ISO string.",
+  inputSchema: z.object({}),
+  execute: async () => ({ now: new Date().toISOString() }),
+});
+
+export const agents = {
+  assistant: new Agent({
+    id: "assistant",
+    instructions: "You are a helpful assistant.",
+    model: new AIModel(${p.providerFn}("${modelId}")), // reads ${p.envVar} from env/.env
+    tools: [getTime],
+    store,
+    prices: defaultPrices, // bundled price table \u2014 cost.usd populated in every run result
+  }),
+};
+`;
+}
+function srcAgentTs(p, modelId) {
+  return `try { process.loadEnvFile(); } catch {}
+import { Agent, AIModel, SqliteStore, createTool, defaultPrices } from "eidentic";
+${p.importLine}
+import { z } from "zod";
+
+// Persistent, event-sourced session store.
+const store = new SqliteStore("./eidentic.sqlite");
+await store.migrate();
+
+// A tiny example tool \u2014 replace with your own.
+const getTime = createTool({
+  id: "get_time",
+  description: "Get the current server time as an ISO string.",
+  inputSchema: z.object({}),
+  execute: async () => ({ now: new Date().toISOString() }),
+});
+
+const agent = new Agent({
+  id: "assistant",
+  instructions: "You are a helpful assistant. Use tools when relevant, then answer concisely.",
+  model: new AIModel(${p.providerFn}("${modelId}")), // reads ${p.envVar} from env
+  tools: [getTime],
+  store,
+  prices: defaultPrices, // bundled price table \u2014 cost.usd populated in every run result
+});
+
+for await (const ev of agent.query("What time is it right now?", { sessionId: "session-1" })) {
+  if (ev.type === "result") console.log("\\n" + String(ev.output));
+}
+
+await store.close();
+`;
+}
+function initProject(cwd, opts = {}) {
+  const provider = opts.provider ?? "anthropic";
+  const p = INIT_PROVIDERS[provider];
+  const modelId = opts.model ?? p.modelId;
+  const created = [];
+  const skipped = [];
+  function writeIfAbsent(rel, content) {
+    const abs = join(cwd, rel);
+    if (existsSync(abs)) {
+      skipped.push(rel);
+    } else {
+      const dir = join(cwd, rel.includes("/") ? rel.split("/").slice(0, -1).join("/") : ".");
+      mkdirSync(dir, { recursive: true });
+      writeFileSync(abs, content, "utf8");
+      created.push(rel);
+    }
+  }
+  writeIfAbsent("eidentic.config.ts", eidenticConfigTs(p, modelId));
+  writeIfAbsent("src/agent.ts", srcAgentTs(p, modelId));
+  writeIfAbsent(".env.example", `# Get a key at https://console.anthropic.com (or your provider's dashboard)
+${p.envVar}=
+`);
+  const giAbs = join(cwd, ".gitignore");
+  if (existsSync(giAbs)) {
+    const existing = readFileSync(giAbs, "utf8");
+    if (!existing.split("\n").map((l) => l.trim()).includes(".env")) {
+      appendFileSync(giAbs, "\n.env\n");
+      created.push(".gitignore (appended .env)");
+    } else {
+      skipped.push(".gitignore");
+    }
+  } else {
+    writeFileSync(giAbs, "node_modules\ndist\n*.sqlite\n.env\n", "utf8");
+    created.push(".gitignore");
+  }
+  const envAbs = join(cwd, ".env");
+  if (existsSync(envAbs)) {
+    skipped.push(".env");
+  } else {
+    const envValue = opts.apiKey ? opts.apiKey : "";
+    writeFileSync(envAbs, `${p.envVar}=${envValue}
+`, "utf8");
+    created.push(".env");
+  }
+  return { created, skipped };
+}
+var PROVIDER_KEYS = [
+  "ANTHROPIC_API_KEY",
+  "OPENAI_API_KEY",
+  "GOOGLE_GENERATIVE_AI_API_KEY",
+  "DEEPSEEK_API_KEY",
+  "MISTRAL_API_KEY"
+];
+function doctor(env = process.env, cwd = process.cwd()) {
+  const checks = [];
+  const rawVersion = process.version;
+  const major = parseInt(rawVersion.replace(/^v/, "").split(".")[0] ?? "0", 10);
+  const nodeOk = major >= 22;
+  checks.push({
+    name: "Node.js >= 22",
+    ok: nodeOk,
+    detail: nodeOk ? `Node ${rawVersion} (OK)` : `Node ${rawVersion} is too old \u2014 upgrade to >= 22`
+  });
+  const foundKey = PROVIDER_KEYS.find((k) => Boolean(env[k]));
+  const providerOk = foundKey !== void 0;
+  checks.push({
+    name: "Model provider key",
+    ok: providerOk,
+    detail: providerOk ? `${foundKey} is set` : `None of ${PROVIDER_KEYS.join(", ")} found in environment`
+  });
+  const configPath = resolveConfigPath(cwd);
+  const configOk = configPath !== null;
+  checks.push({
+    name: "eidentic.config file",
+    ok: configOk,
+    detail: configOk ? `Found ${configPath}` : `No eidentic.config.{ts,js,mjs} in ${cwd}`
+  });
+  const dotEnvExists = existsSync(join(cwd, ".env"));
+  checks.push({
+    name: ".env file",
+    ok: true,
+    detail: dotEnvExists ? `Found ${join(cwd, ".env")}` : `No .env in ${cwd} (optional \u2014 set env vars another way)`
+  });
+  const ok = checks.every((c) => c.ok);
+  return { checks, ok };
+}
+var CONFIG_NAMES = ["eidentic.config.ts", "eidentic.config.js", "eidentic.config.mjs"];
+function resolveConfigPath(cwd, explicit) {
+  if (explicit) {
+    return existsSync(explicit) ? explicit : null;
+  }
+  for (const name of CONFIG_NAMES) {
+    const full = join(cwd, name);
+    if (existsSync(full)) return full;
+  }
+  return null;
+}
+async function loadConfig(configPath) {
+  const jiti = createJiti(import.meta.url);
+  const raw = await jiti.import(
+    configPath,
+    { default: true }
+  );
+  const config = raw;
+  if (!config || typeof config !== "object" || !config.agents || typeof config.agents !== "object") {
+    throw new Error(
+      `Config at ${configPath} must export an object with an "agents" field (Record<string, Agent>).`
+    );
+  }
+  const agentIds = Object.keys(config.agents);
+  if (agentIds.length === 0) {
+    throw new Error(
+      `Config at ${configPath} has an empty "agents" object \u2014 add at least one agent.`
+    );
+  }
+  return config;
+}
+function buildServer(config) {
+  return createServer({
+    agents: config.agents,
+    auth: config.auth,
+    basePath: config.basePath,
+    exposeEvents: config.exposeEvents
+  });
+}
+function computePassRate(aggregate) {
+  const entries = Object.values(aggregate);
+  return entries.length === 0 ? 0 : entries.reduce((sum, e) => sum + e.pass, 0) / entries.length;
+}
+async function runEval(configPath, opts = {}) {
+  const jiti = createJiti(import.meta.url);
+  const raw = await jiti.import(configPath, { default: true });
+  const evalConfig = raw;
+  if (!evalConfig || typeof evalConfig !== "object" || !evalConfig.runner || !evalConfig.dataset || !evalConfig.scorers) {
+    throw new Error(
+      `Eval config at ${configPath} must export { runner, dataset, scorers } (and optionally samples).`
+    );
+  }
+  const evalMod = await import("@eidentic/eval");
+  const report = await evalMod.evaluate(
+    evalConfig.runner,
+    evalConfig.dataset,
+    {
+      scorers: evalConfig.scorers,
+      samples: evalConfig.samples
+    }
+  );
+  const summary = evalMod.summarize(report);
+  const passRate = computePassRate(report.aggregate);
+  let compareResult;
+  if (opts.baselinePath) {
+    const baselineRaw = readFileSync(opts.baselinePath, "utf8");
+    const baseline = JSON.parse(baselineRaw);
+    compareResult = evalMod.compareReports(baseline, report);
+  }
+  const markdownReport = evalMod.renderReportMarkdown(
+    report,
+    compareResult ? { compare: compareResult } : {}
+  );
+  if (opts.reportPath) {
+    const reportDir = dirname(opts.reportPath);
+    if (reportDir && reportDir !== ".") {
+      mkdirSync(reportDir, { recursive: true });
+    }
+    writeFileSync(opts.reportPath, markdownReport, "utf8");
+  }
+  if (opts.saveBaselinePath) {
+    const baselineDir = dirname(opts.saveBaselinePath);
+    if (baselineDir && baselineDir !== ".") {
+      mkdirSync(baselineDir, { recursive: true });
+    }
+    writeFileSync(opts.saveBaselinePath, JSON.stringify(report, null, 2), "utf8");
+  }
+  if (opts.ci) {
+    if (compareResult && compareResult.verdict === "regressed") {
+      const regressionMsg = compareResult.regressions.map((r) => `  - ${r.caseName}/${r.scorer}: ${(r.baseline * 100).toFixed(1)}% \u2192 ${(r.current * 100).toFixed(1)}% (${(r.delta * 100).toFixed(1)}pp)`).join("\n");
+      const err = new Error(
+        `Eval regressions detected (${compareResult.regressions.length}):
+${regressionMsg}`
+      );
+      err.name = "EvalRegressionError";
+      err.actualPassRate = passRate;
+      err.requiredPassRate = opts.threshold ?? 1;
+      throw err;
+    }
+    evalMod.assertPassRate(report, opts.threshold ?? 1);
+  }
+  return { summary, report, passRate, compareResult, markdownReport };
+}
+var SKILLS_DIR_NAME = "skills";
+function makeDirResolver(sourceDir) {
+  return (name) => {
+    const candidate = join(resolve(sourceDir), name);
+    if (existsSync(candidate) && statSync(candidate).isDirectory()) {
+      return candidate;
+    }
+    return null;
+  };
+}
+async function addSkill(source, opts = {}) {
+  const projectRoot = opts.projectRoot ?? process.cwd();
+  const resolver = opts.resolver ?? (() => null);
+  const force = opts.force ?? false;
+  let skillSrcDir;
+  const isPath = isAbsolute(source) || source.startsWith(".") || source.includes("/");
+  if (isPath) {
+    skillSrcDir = isAbsolute(source) ? source : resolve(projectRoot, source);
+  } else {
+    const resolved = resolver(source);
+    if (resolved === null) {
+      throw new Error(
+        `addSkill: cannot resolve skill "${source}". Pass a path (starting with . / .. or absolute) or inject a resolver that knows where to find "${source}".`
+      );
+    }
+    skillSrcDir = resolved;
+  }
+  if (!existsSync(skillSrcDir)) {
+    throw new Error(`addSkill: source not found: "${skillSrcDir}"`);
+  }
+  const srcStat = statSync(skillSrcDir);
+  if (!srcStat.isDirectory()) {
+    throw new Error(
+      `addSkill: source must be a directory containing SKILL.md, got a file: "${skillSrcDir}"`
+    );
+  }
+  const skillMdPath = join(skillSrcDir, "SKILL.md");
+  if (!existsSync(skillMdPath)) {
+    throw new Error(
+      `addSkill: no SKILL.md found in "${skillSrcDir}". A skill directory must contain a SKILL.md file.`
+    );
+  }
+  const skillMdContent = readFileSync(skillMdPath, "utf8");
+  let parseSkillMd;
+  try {
+    const mod = await import("./dist-DDLWLV6O.js");
+    parseSkillMd = mod.parseSkillMd;
+  } catch {
+    throw new Error(
+      "addSkill: @eidentic/skills is not installed. Add it to your project to use `eidentic add skill`."
+    );
+  }
+  let manifest;
+  try {
+    ({ manifest } = parseSkillMd(skillMdContent));
+  } catch (err) {
+    throw new Error(
+      `addSkill: invalid SKILL.md in "${skillSrcDir}": ${err.message}`
+    );
+  }
+  const skillsDir = join(projectRoot, SKILLS_DIR_NAME);
+  const destDir = join(skillsDir, manifest.name);
+  const alreadyExists = existsSync(destDir);
+  if (alreadyExists && !force) {
+    throw new Error(
+      `addSkill: skill "${manifest.name}" already exists at "${destDir}". Pass --force to overwrite.`
+    );
+  }
+  const executableFiles = collectExecutableFiles(skillSrcDir);
+  if (executableFiles.length > 0) {
+    const warn = opts.warnImpl ?? console.warn;
+    warn(
+      `[eidentic add skill] The skill bundle contains executable file(s) \u2014 review before trusting:
+` + executableFiles.map((f) => `  \u2022 ${f}`).join("\n")
+    );
+  }
+  mkdirSync(destDir, { recursive: true });
+  copySkillDir(skillSrcDir, destDir);
+  return {
+    name: manifest.name,
+    installedAt: destDir,
+    replaced: alreadyExists
+  };
+}
+var EXECUTABLE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".js", ".mjs", ".cjs", ".tsx", ".jsx", ".sh", ".py", ".rb", ".pl"]);
+function collectExecutableFiles(dir, base = "") {
+  const results = [];
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isSymbolicLink()) continue;
+    if (entry.name === ".memory.md") continue;
+    const rel = base ? `${base}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      results.push(...collectExecutableFiles(join(dir, entry.name), rel));
+    } else if (entry.isFile()) {
+      const ext = entry.name.includes(".") ? `.${entry.name.split(".").pop().toLowerCase()}` : "";
+      if (EXECUTABLE_EXTENSIONS.has(ext)) {
+        results.push(rel);
+      }
+    }
+  }
+  return results;
+}
+function copySkillDir(src, dest) {
+  const entries = readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isSymbolicLink()) continue;
+    if (entry.name === ".memory.md") continue;
+    const srcPath = join(src, entry.name);
+    const destPath = join(dest, entry.name);
+    if (entry.isDirectory()) {
+      mkdirSync(destPath, { recursive: true });
+      copySkillDir(srcPath, destPath);
+    } else if (entry.isFile()) {
+      copyFileSync(srcPath, destPath);
+    }
+  }
+}
+var COMPONENT_NAMES = ["chat", "workflow-trace", "run-status"];
+var COMPONENT_DESCRIPTIONS = {
+  chat: "Full-featured streaming chat UI using useAgent (messages, tool-call display, stop).",
+  "workflow-trace": "Workflow run trace viewer using useWorkflowRun (step timeline, status badges).",
+  "run-status": "Fire-and-poll async run status badge using useAsyncRun and useRunStatus."
+};
+var COMPONENTS_DIR_NAME = "components/eidentic";
+function resolveBuiltinTemplatesDir() {
+  let pkgRoot;
+  try {
+    pkgRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+  } catch {
+    pkgRoot = dirname(dirname(globalThis.__filename ?? __filename));
+  }
+  return join(pkgRoot, "templates", "components");
+}
+function addComponent(name, opts = {}) {
+  if (!COMPONENT_NAMES.includes(name)) {
+    throw new Error(
+      `addComponent: unknown component "${name}". Available components: ${COMPONENT_NAMES.join(", ")}.`
+    );
+  }
+  const componentName = name;
+  const projectRoot = opts.projectRoot ?? process.cwd();
+  const force = opts.force ?? opts.overwrite ?? false;
+  const relTargetDir = opts.targetDir ?? COMPONENTS_DIR_NAME;
+  const templatesDir = opts.templatesDir ?? resolveBuiltinTemplatesDir();
+  const srcFile = join(templatesDir, `${componentName}.tsx`);
+  if (!existsSync(srcFile)) {
+    throw new Error(
+      `addComponent: template file not found: "${srcFile}". This is a bug in @eidentic/cli \u2014 please file an issue.`
+    );
+  }
+  const destDir = join(projectRoot, relTargetDir);
+  const destFile = join(destDir, `${componentName}.tsx`);
+  const alreadyExists = existsSync(destFile);
+  if (alreadyExists && !force) {
+    throw new Error(
+      `addComponent: component "${componentName}" already exists at "${destFile}". Pass --force to overwrite.`
+    );
+  }
+  mkdirSync(destDir, { recursive: true });
+  copyFileSync(srcFile, destFile);
+  return {
+    name: componentName,
+    installedAt: destFile,
+    replaced: alreadyExists
+  };
+}
+
+// src/index.ts
+import { serveNode, NoAuth } from "@eidentic/server";
+try {
+  process.loadEnvFile();
+} catch {
+}
+var __dirname = dirname2(fileURLToPath2(import.meta.url));
+var _require = createRequire(import.meta.url);
+var PKG_VERSION = "0.0.0";
+try {
+  const pkg = _require(join2(__dirname, "../package.json"));
+  PKG_VERSION = pkg.version;
+} catch {
+}
+var doctorCmd = defineCommand({
+  meta: {
+    name: "doctor",
+    description: "Check environment readiness: Node version, model-provider key, config file."
+  },
+  async run() {
+    const report = doctor();
+    for (const check of report.checks) {
+      if (check.ok) {
+        consola.log(`  ${pc.green("\u2713")} ${check.name}: ${check.detail}`);
+      } else {
+        consola.log(`  ${pc.red("\u2717")} ${check.name}: ${check.detail}`);
+      }
+    }
+    consola.log("");
+    if (report.ok) {
+      consola.success("All checks passed.");
+    } else {
+      consola.error("Some checks failed. Fix the issues above before running eidentic dev.");
+      process.exit(1);
+    }
+  }
+});
+var devCmd = defineCommand({
+  meta: {
+    name: "dev",
+    description: "Start a local dev server. Loads eidentic.config.{ts,js,mjs} from the current directory (or an explicit path)."
+  },
+  args: {
+    config: {
+      type: "positional",
+      description: "Path to eidentic config file (optional)",
+      required: false
+    },
+    port: {
+      type: "string",
+      description: "Port to listen on (default: 3000)",
+      alias: ["p"]
+    }
+  },
+  async run({ args }) {
+    const explicitPath = args.config;
+    const port = args.port ? parseInt(String(args.port), 10) : void 0;
+    const configPath = resolveConfigPath(process.cwd(), explicitPath);
+    if (!configPath) {
+      consola.error("No eidentic.config.{ts,js,mjs} found.");
+      consola.info(
+        "Create a eidentic.config.ts in the current directory, or pass the path explicitly."
+      );
+      consola.info("Run `eidentic doctor` for a full environment check.");
+      process.exit(1);
+    }
+    let config;
+    try {
+      config = await loadConfig(configPath);
+    } catch (err) {
+      consola.error(`Error loading config: ${err.message}`);
+      process.exit(1);
+    }
+    const app = buildServer(config);
+    const listenPort = port ?? config.port ?? 3e3;
+    let handle;
+    try {
+      handle = await serveNode(app, { port: listenPort });
+    } catch (err) {
+      consola.error(`Failed to start server: ${err.message}`);
+      process.exit(1);
+    }
+    const agentIds = Object.keys(config.agents);
+    consola.success(
+      `eidentic dev server running at ${pc.cyan(`http://localhost:${listenPort}`)}`
+    );
+    consola.info(`Agents: ${pc.bold(agentIds.join(", "))}`);
+    consola.info("Press Ctrl+C to stop.");
+    process.on("SIGINT", () => {
+      handle.close();
+      process.exit(0);
+    });
+  }
+});
+function openBrowser(url) {
+  try {
+    const platform = process.platform;
+    let cmd;
+    let args;
+    if (platform === "darwin") {
+      cmd = "open";
+      args = [url];
+    } else if (platform === "win32") {
+      cmd = "cmd";
+      args = ["/c", "start", url];
+    } else {
+      cmd = "xdg-open";
+      args = [url];
+    }
+    spawn(cmd, args, { detached: true, stdio: "ignore" }).unref();
+  } catch {
+  }
+}
+var studioCmd = defineCommand({
+  meta: {
+    name: "studio",
+    description: "Start Eidentic Studio (dev tool) on port 3535. Loads eidentic.config.{ts,js,mjs} from the current directory."
+  },
+  args: {
+    config: {
+      type: "positional",
+      description: "Path to eidentic config file (optional)",
+      required: false
+    },
+    port: {
+      type: "string",
+      description: "Port to listen on (default: 3535)",
+      alias: ["p"]
+    }
+  },
+  async run({ args }) {
+    const explicitPath = args.config;
+    const port = args.port ? parseInt(String(args.port), 10) : 3535;
+    const configPath = resolveConfigPath(process.cwd(), explicitPath);
+    if (!configPath) {
+      consola.error("No eidentic.config.{ts,js,mjs} found.");
+      consola.info(
+        "Create a eidentic.config.ts in the current directory, or pass the path explicitly."
+      );
+      process.exit(1);
+    }
+    let config;
+    try {
+      config = await loadConfig(configPath);
+    } catch (err) {
+      consola.error(`Error loading config: ${err.message}`);
+      process.exit(1);
+    }
+    if (config.auth && config.auth !== NoAuth) {
+      consola.warn(`Studio auth is active. Open the studio URL with ?key=<your-token> appended so the UI can authenticate (e.g. http://localhost:${port}/?key=<your-token>).`);
+    }
+    let serveStudio;
+    try {
+      const studioMod = await import("@eidentic/studio");
+      serveStudio = studioMod.serveStudio;
+    } catch (err) {
+      consola.error(`Failed to load @eidentic/studio: ${err.message}`);
+      consola.info("Make sure @eidentic/studio is installed.");
+      process.exit(1);
+    }
+    let handle;
+    try {
+      handle = await serveStudio(
+        {
+          agents: config.agents,
+          auth: config.auth,
+          skillBanks: config.skillBanks
+        },
+        { port }
+      );
+    } catch (err) {
+      consola.error(`Failed to start studio: ${err.message}`);
+      process.exit(1);
+    }
+    const url = `http://localhost:${port}`;
+    consola.success(`Eidentic Studio \u2192 ${pc.cyan(url)}`);
+    consola.info("Press Ctrl+C to stop.");
+    openBrowser(url);
+    process.on("SIGINT", () => {
+      handle.close();
+      process.exit(0);
+    });
+  }
+});
+var PROVIDER_CHOICES = ["anthropic", "openai", "google", "deepseek", "mistral"];
+var OTHER_MODEL_SENTINEL = "__other__";
+function detectPackageManager(cwd) {
+  if (existsSync2(join2(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync2(join2(cwd, "yarn.lock"))) return "yarn";
+  if (existsSync2(join2(cwd, "bun.lockb"))) return "bun";
+  return "npm";
+}
+function spawnInstall(pm, pkgs, devPkgs) {
+  return new Promise((resolve2, reject) => {
+    const installArgs = pm === "npm" ? ["install"] : ["add"];
+    const devFlag = pm === "npm" ? "--save-dev" : "-D";
+    const child = spawn(pm, [...installArgs, ...pkgs], { stdio: "inherit" });
+    child.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(`${pm} install exited with code ${code}`));
+        return;
+      }
+      const devChild = spawn(pm, [...installArgs, devFlag, ...devPkgs], { stdio: "inherit" });
+      devChild.on("close", (devCode) => {
+        if (devCode !== 0) {
+          reject(new Error(`${pm} install -D exited with code ${devCode}`));
+          return;
+        }
+        resolve2();
+      });
+      devChild.on("error", reject);
+    });
+    child.on("error", reject);
+  });
+}
+function printInitResult(created, skipped) {
+  for (const f of created) {
+    consola.log(`  ${pc.green("+")} ${f}`);
+  }
+  for (const f of skipped) {
+    consola.log(`  ${pc.yellow("~")} ${f} ${pc.dim("(already exists, skipped)")}`);
+  }
+}
+function printNextSteps(provider, apiKeyProvided) {
+  consola.log("");
+  consola.success("Eidentic init complete.");
+  consola.log("");
+  consola.log(pc.bold("Next steps:"));
+  let step = 1;
+  if (!apiKeyProvided) {
+    const envVar = INIT_PROVIDERS[provider].envVar;
+    consola.log(`  ${pc.cyan(`${step})`)} Add your API key to ${pc.bold(".env")}: ${pc.dim(`${envVar}=<your-key>`)}`);
+    step++;
+  }
+  consola.log(`  ${pc.cyan(`${step})`)} ${pc.cyan("npx eidentic dev")}  ${pc.dim("(or npx eidentic studio)")}`);
+  consola.log(`  ${pc.cyan(`${step + 1})`)} ${pc.cyan("npx tsx src/agent.ts")}  ${pc.dim("(run the agent script directly)")}`);
+}
+var initCmd = defineCommand({
+  meta: {
+    name: "init",
+    description: "Scaffold Eidentic into the current directory. Creates eidentic.config.ts, src/agent.ts, .env, .env.example, .gitignore. Idempotent \u2014 never overwrites existing files."
+  },
+  args: {
+    provider: {
+      type: "string",
+      description: `Model provider (${PROVIDER_CHOICES.join(" | ")}). Default: anthropic`,
+      alias: ["p"]
+    },
+    model: {
+      type: "string",
+      description: "Model ID to use (e.g. claude-sonnet-4-5). Defaults to the provider default.",
+      alias: ["m"]
+    },
+    "api-key": {
+      type: "string",
+      description: "API key to write into .env (optional \u2014 can be added later)."
+    },
+    yes: {
+      type: "boolean",
+      description: "Skip interactive prompts; use flags/defaults. Does not install deps unless --install is also given.",
+      alias: ["y"]
+    },
+    install: {
+      type: "boolean",
+      description: "Install dependencies after scaffolding (default: prompted interactively)."
+    }
+  },
+  async run({ args }) {
+    const isInteractive = process.stdin.isTTY && !args.yes;
+    let provider;
+    {
+      const rawProvider = args.provider;
+      if (rawProvider) {
+        if (!PROVIDER_CHOICES.includes(rawProvider)) {
+          consola.error(`Unknown provider "${rawProvider}". Choose one of: ${PROVIDER_CHOICES.join(", ")}`);
+          process.exit(1);
+        }
+        provider = rawProvider;
+      } else if (isInteractive) {
+        const { intro, select, isCancel, cancel } = await import("@clack/prompts");
+        intro(pc.bold("eidentic init"));
+        const providerAnswer = await select({
+          message: "Model provider",
+          options: [
+            { value: "anthropic", label: "Anthropic", hint: "Claude \u2014 needs ANTHROPIC_API_KEY" },
+            { value: "openai", label: "OpenAI", hint: "GPT \u2014 needs OPENAI_API_KEY" },
+            { value: "google", label: "Google", hint: "Gemini \u2014 needs GOOGLE_GENERATIVE_AI_API_KEY" },
+            { value: "deepseek", label: "DeepSeek", hint: "needs DEEPSEEK_API_KEY" },
+            { value: "mistral", label: "Mistral", hint: "needs MISTRAL_API_KEY" }
+          ]
+        });
+        if (isCancel(providerAnswer)) {
+          cancel("Cancelled.");
+          process.exit(0);
+        }
+        provider = providerAnswer;
+      } else {
+        provider = "anthropic";
+      }
+    }
+    const providerMeta = INIT_PROVIDERS[provider];
+    let model;
+    {
+      const rawModel = args.model;
+      if (rawModel) {
+        model = rawModel;
+      } else if (isInteractive) {
+        const { select, text, isCancel, cancel } = await import("@clack/prompts");
+        const modelOptions = [
+          ...providerMeta.models.map((m) => ({ value: m, label: m })),
+          { value: OTHER_MODEL_SENTINEL, label: "Other (type manually)" }
+        ];
+        const modelAnswer = await select({ message: "Model", options: modelOptions });
+        if (isCancel(modelAnswer)) {
+          cancel("Cancelled.");
+          process.exit(0);
+        }
+        if (modelAnswer === OTHER_MODEL_SENTINEL) {
+          const customModel = await text({
+            message: "Enter model ID",
+            placeholder: providerMeta.modelId
+          });
+          if (isCancel(customModel)) {
+            cancel("Cancelled.");
+            process.exit(0);
+          }
+          model = customModel || providerMeta.modelId;
+        } else {
+          model = modelAnswer;
+        }
+      } else {
+        model = providerMeta.modelId;
+      }
+    }
+    let apiKey;
+    {
+      const rawKey = args["api-key"];
+      if (rawKey !== void 0) {
+        apiKey = rawKey || void 0;
+      } else if (isInteractive) {
+        const { password, isCancel, cancel } = await import("@clack/prompts");
+        const keyAnswer = await password({
+          message: `API key for ${providerMeta.envVar} (leave blank to add later)`
+        });
+        if (isCancel(keyAnswer)) {
+          cancel("Cancelled.");
+          process.exit(0);
+        }
+        apiKey = keyAnswer || void 0;
+      }
+    }
+    let shouldInstall;
+    {
+      if (args.install !== void 0) {
+        shouldInstall = Boolean(args.install);
+      } else if (isInteractive) {
+        const { confirm, isCancel, cancel } = await import("@clack/prompts");
+        const installAnswer = await confirm({
+          message: `Install dependencies now? (eidentic, ai, @ai-sdk/${provider}, zod)`,
+          initialValue: true
+        });
+        if (isCancel(installAnswer)) {
+          cancel("Cancelled.");
+          process.exit(0);
+        }
+        shouldInstall = Boolean(installAnswer);
+      } else {
+        shouldInstall = false;
+      }
+    }
+    const cwd = process.cwd();
+    if (!isInteractive) {
+      consola.info(`Scaffolding Eidentic into ${pc.cyan(cwd)} (provider: ${pc.bold(provider)}, model: ${pc.bold(model)})`);
+    }
+    const { created, skipped } = initProject(cwd, { provider, model, apiKey });
+    printInitResult(created, skipped);
+    if (shouldInstall) {
+      const pm = detectPackageManager(cwd);
+      const prodPkgs = ["eidentic", "ai", `@ai-sdk/${provider}`, "zod"];
+      const devPkgs = ["tsx", "typescript"];
+      consola.info(`Running ${pm} install...`);
+      try {
+        await spawnInstall(pm, prodPkgs, devPkgs);
+        consola.success("Dependencies installed.");
+      } catch (err) {
+        consola.warn(`Install failed: ${err.message}`);
+        consola.info(`Run manually: ${pm} ${pm === "npm" ? "install" : "add"} ${prodPkgs.join(" ")}`);
+      }
+    }
+    if (isInteractive) {
+      const { outro } = await import("@clack/prompts");
+      const steps = [];
+      if (!apiKey) {
+        steps.push(`Set your API key in .env: ${providerMeta.envVar}=<your-key>`);
+      }
+      if (!shouldInstall) {
+        steps.push(`Install deps: ${detectPackageManager(cwd)} ${detectPackageManager(cwd) === "npm" ? "install" : "add"} eidentic ai @ai-sdk/${provider} zod`);
+      }
+      steps.push("Start dev server: npx eidentic dev");
+      steps.push("Or run the agent: npx tsx src/agent.ts");
+      outro(
+        [pc.bold("Done!"), "", ...steps.map((s, i) => `  ${pc.cyan(`${i + 1})`)} ${s}`)].join("\n")
+      );
+    } else {
+      printNextSteps(provider, Boolean(apiKey));
+    }
+  }
+});
+var evalCmd = defineCommand({
+  meta: {
+    name: "eval",
+    description: "Run an evaluation against a config/dataset file. Prints a summary and, with --ci, exits non-zero when the pass rate is below --threshold or when regressions are detected against --baseline."
+  },
+  args: {
+    config: {
+      type: "positional",
+      description: "Path to the eval config file (.ts/.js/.mjs) that exports { runner, dataset, scorers }.",
+      required: true
+    },
+    ci: {
+      type: "boolean",
+      description: "Exit non-zero when the pass rate is below --threshold or regressions are detected.",
+      default: false
+    },
+    threshold: {
+      type: "string",
+      description: "Pass-rate threshold in [0, 1] (default: 1). Only used with --ci.",
+      alias: ["t"]
+    },
+    baseline: {
+      type: "string",
+      description: "Path to a baseline EvalReport JSON file. When provided, compares current run against the baseline and fails CI on any regression."
+    },
+    "save-baseline": {
+      type: "string",
+      description: "Path where the current EvalReport will be saved as a JSON baseline snapshot."
+    },
+    report: {
+      type: "string",
+      description: "Path where the Markdown eval report will be written (GitHub-comment-friendly)."
+    }
+  },
+  async run({ args }) {
+    const configPath = args.config;
+    const ci = Boolean(args.ci);
+    const threshold = args.threshold ? parseFloat(String(args.threshold)) : 1;
+    const baselinePath = args.baseline;
+    const saveBaselinePath = args["save-baseline"];
+    const reportPath = args.report;
+    if (ci && (isNaN(threshold) || threshold < 0 || threshold > 1)) {
+      consola.error(`--threshold must be a number in [0, 1], got: ${args.threshold}`);
+      process.exit(1);
+    }
+    let result;
+    try {
+      result = await runEval(configPath, { ci, threshold, baselinePath, saveBaselinePath, reportPath });
+    } catch (err) {
+      const e = err;
+      if (e.name === "EvalThresholdError") {
+        consola.log(e.message);
+        consola.error(
+          `CI gate FAILED \u2014 pass rate ${(e.actualPassRate * 100).toFixed(1)}% < required ${(e.requiredPassRate * 100).toFixed(1)}%`
+        );
+        process.exit(1);
+      }
+      if (e.name === "EvalRegressionError") {
+        consola.log(e.message);
+        consola.error("CI gate FAILED \u2014 regressions detected against baseline.");
+        process.exit(1);
+      }
+      consola.error(`Eval failed: ${e.message}`);
+      process.exit(1);
+    }
+    consola.log(result.summary);
+    consola.log("");
+    consola.success(`Pass rate: ${pc.bold((result.passRate * 100).toFixed(1) + "%")}`);
+    if (result.compareResult) {
+      const { regressions, improvements, unchanged, verdict } = result.compareResult;
+      consola.log(`Baseline comparison: ${verdict === "pass" ? pc.green("no regressions") : pc.red(`${regressions.length} regression(s)`)}, ${improvements.length} improvement(s), ${unchanged} unchanged.`);
+    }
+    if (reportPath) {
+      consola.success(`Markdown report written to ${pc.cyan(reportPath)}`);
+    }
+    if (saveBaselinePath) {
+      consola.success(`Baseline snapshot saved to ${pc.cyan(saveBaselinePath)}`);
+    }
+    if (ci) {
+      consola.success("CI gate passed.");
+    }
+  }
+});
+var addSkillCmd = defineCommand({
+  meta: {
+    name: "skill",
+    description: "Install a skill into the project's local skills directory (skills/<name>/)."
+  },
+  args: {
+    source: {
+      type: "positional",
+      description: "Path to a skill directory (must contain SKILL.md), or a skill name resolvable via --from.",
+      required: true
+    },
+    force: {
+      type: "boolean",
+      description: "Overwrite an existing skill with the same name.",
+      alias: ["f"],
+      default: false
+    },
+    from: {
+      type: "string",
+      description: "Path to a local skills source directory (a directory of skill subdirs). Used when <source> is a name rather than a path."
+    },
+    cwd: {
+      type: "string",
+      description: "Project root to install into (default: current directory)."
+    }
+  },
+  async run({ args }) {
+    const source = args.source;
+    const force = Boolean(args.force);
+    const fromDir = args.from;
+    const projectRoot = args.cwd ?? process.cwd();
+    const resolver = fromDir ? makeDirResolver(fromDir) : void 0;
+    let result;
+    try {
+      result = await addSkill(source, { force, resolver, projectRoot });
+    } catch (err) {
+      consola.error(err.message);
+      process.exit(1);
+    }
+    if (result.replaced) {
+      consola.success(
+        `Skill ${pc.bold(result.name)} replaced at ${pc.cyan(result.installedAt)}`
+      );
+    } else {
+      consola.success(
+        `Skill ${pc.bold(result.name)} installed at ${pc.cyan(result.installedAt)}`
+      );
+    }
+  }
+});
+var addComponentCmd = defineCommand({
+  meta: {
+    name: "component",
+    description: `Copy a pre-built UI component into the project (components/eidentic/<name>.tsx). Use --list to see all available components.`
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: `Component name: ${COMPONENT_NAMES.join(" | ")}. Omit when using --list.`,
+      required: false
+    },
+    list: {
+      type: "boolean",
+      description: "List available components with descriptions and exit.",
+      alias: ["l"],
+      default: false
+    },
+    overwrite: {
+      type: "boolean",
+      description: "Overwrite an existing component file (required if the file already exists).",
+      alias: ["f"],
+      default: false
+    },
+    dir: {
+      type: "string",
+      description: "Target directory relative to --cwd (default: components/eidentic)."
+    },
+    cwd: {
+      type: "string",
+      description: "Project root to install into (default: current directory)."
+    }
+  },
+  run({ args }) {
+    if (args.list) {
+      consola.log(pc.bold("Available components:"));
+      consola.log("");
+      for (const name2 of COMPONENT_NAMES) {
+        consola.log(`  ${pc.cyan(pc.bold(name2))}`);
+        consola.log(`    ${pc.dim(COMPONENT_DESCRIPTIONS[name2])}`);
+      }
+      consola.log("");
+      consola.info(`Install with: ${pc.cyan("eidentic add component <name>")}`);
+      return;
+    }
+    const name = args.name;
+    if (!name) {
+      consola.error("Component name is required. Use --list to see available components.");
+      consola.info(`Available components: ${pc.bold(COMPONENT_NAMES.join(", "))}`);
+      process.exit(1);
+    }
+    const overwrite = Boolean(args.overwrite);
+    const projectRoot = args.cwd ?? process.cwd();
+    const targetDir = args.dir;
+    let result;
+    try {
+      result = addComponent(name, { overwrite, projectRoot, targetDir });
+    } catch (err) {
+      const msg = err.message;
+      if (msg.includes("unknown component")) {
+        consola.error(msg);
+        consola.info(`Available components: ${pc.bold(COMPONENT_NAMES.join(", "))}`);
+      } else if (msg.includes("already exists")) {
+        consola.error(msg);
+        consola.info(`Re-run with ${pc.bold("--overwrite")} to replace the existing file.`);
+      } else {
+        consola.error(msg);
+      }
+      process.exit(1);
+    }
+    if (result.replaced) {
+      consola.success(
+        `Component ${pc.bold(result.name)} replaced at ${pc.cyan(result.installedAt)}`
+      );
+    } else {
+      consola.success(
+        `Component ${pc.bold(result.name)} installed at ${pc.cyan(result.installedAt)}`
+      );
+    }
+  }
+});
+var addCmd = defineCommand({
+  meta: {
+    name: "add",
+    description: "Add resources to the current Eidentic project."
+  },
+  subCommands: {
+    skill: addSkillCmd,
+    component: addComponentCmd
+  }
+});
+var main = defineCommand({
+  meta: {
+    name: "eidentic",
+    version: PKG_VERSION,
+    description: "Eidentic agent toolkit CLI"
+  },
+  subCommands: {
+    doctor: doctorCmd,
+    dev: devCmd,
+    eval: evalCmd,
+    studio: studioCmd,
+    init: initCmd,
+    add: addCmd
+  }
+});
+runMain(main);