@recursiv/cli 0.1.0

package/dist/bin/recursiv.js

@@ -0,0 +1,2001 @@
+#!/usr/bin/env node
+
+// src/bin/recursiv.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import { existsSync as existsSync2 } from "fs";
+import { mkdir } from "fs/promises";
+import { resolve } from "path";
+import { execSync } from "child_process";
+import prompts2 from "prompts";
+import pc3 from "picocolors";
+import ora2 from "ora";
+
+// src/lib/logger.ts
+import pc from "picocolors";
+var log = {
+  info(msg) {
+    console.log(pc.cyan("info") + "  " + msg);
+  },
+  success(msg) {
+    console.log(pc.green("ok") + "    " + msg);
+  },
+  warn(msg) {
+    console.log(pc.yellow("warn") + "  " + msg);
+  },
+  error(msg) {
+    console.error(pc.red("error") + " " + msg);
+  },
+  step(n, total, msg) {
+    console.log(pc.dim(`[${n}/${total}]`) + " " + msg);
+  },
+  blank() {
+    console.log();
+  }
+};
+function banner() {
+  console.log();
+  console.log(pc.bold("Recursiv") + pc.dim(" \u2014 build and ship apps with AI"));
+  console.log();
+}
+
+// src/lib/config.ts
+import { readFile, writeFile } from "fs/promises";
+import { join } from "path";
+var CONFIG_FILE = ".recursiv.json";
+function configPath(dir) {
+  return join(dir, CONFIG_FILE);
+}
+async function readConfig(dir) {
+  try {
+    const raw = await readFile(configPath(dir), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeConfig(dir, config) {
+  await writeFile(configPath(dir), JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function createConfig(opts) {
+  return {
+    version: 1,
+    project: {
+      name: opts.name,
+      template: opts.template,
+      framework: opts.framework
+    },
+    api: {
+      baseUrl: "https://recursiv.io/api/v1"
+    },
+    dev: {
+      port: opts.port ?? 3e3,
+      command: opts.devCommand ?? "npm run dev"
+    }
+  };
+}
+
+// src/lib/env.ts
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { join as join2 } from "path";
+async function writeEnvFile(dir, apiKey) {
+  const envPath = join2(dir, ".env");
+  const content = [
+    "# Recursiv API key",
+    `RECURSIV_API_KEY=${apiKey}`,
+    "",
+    "# Framework-specific public keys (uncomment as needed)",
+    `# NEXT_PUBLIC_RECURSIV_API_KEY=${apiKey}`,
+    `# VITE_RECURSIV_API_KEY=${apiKey}`,
+    ""
+  ].join("\n");
+  await writeFile2(envPath, content, "utf-8");
+}
+async function readApiKeyFromEnv(dir) {
+  try {
+    const raw = await readFile2(join2(dir, ".env"), "utf-8");
+    const match = raw.match(/^RECURSIV_API_KEY=(.+)$/m);
+    return match?.[1]?.trim() ?? null;
+  } catch {
+    return null;
+  }
+}
+async function updateApiKeyInEnv(dir, apiKey) {
+  const envPath = join2(dir, ".env");
+  let content;
+  try {
+    content = await readFile2(envPath, "utf-8");
+    if (content.includes("RECURSIV_API_KEY=")) {
+      content = content.replace(/^RECURSIV_API_KEY=.+$/m, `RECURSIV_API_KEY=${apiKey}`);
+    } else {
+      content += `
+RECURSIV_API_KEY=${apiKey}
+`;
+    }
+  } catch {
+    content = `RECURSIV_API_KEY=${apiKey}
+`;
+  }
+  await writeFile2(envPath, content, "utf-8");
+}
+
+// src/lib/templates.ts
+import degit from "degit";
+import ora from "ora";
+async function cloneTemplate(template, dest) {
+  const spinner = ora(`Cloning ${template.name} template...`).start();
+  try {
+    const emitter = degit(template.repo, {
+      cache: false,
+      force: true,
+      verbose: false
+    });
+    await emitter.clone(dest);
+    spinner.succeed(`Template cloned successfully`);
+  } catch (err) {
+    spinner.fail("Failed to clone template");
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      `Could not clone template from ${template.repo}.
+Make sure you have internet access and the repo exists.
+Details: ${message}`
+    );
+  }
+}
+
+// src/lib/auth-flow.ts
+import prompts from "prompts";
+import pc2 from "picocolors";
+var API_KEY_PATTERN = /^sk_(live|test)_[a-zA-Z0-9]{20,}$/;
+var DASHBOARD_URL = "https://recursiv.io/dashboard/api-keys";
+var DEFAULT_SCOPES = [
+  "posts:read",
+  "posts:write",
+  "chat:read",
+  "chat:write",
+  "agents:read",
+  "agents:write",
+  "projects:read",
+  "projects:write",
+  "communities:read",
+  "communities:write",
+  "users:read"
+];
+function isValidKeyFormat(key) {
+  return API_KEY_PATTERN.test(key);
+}
+async function validateApiKey(apiKey, baseUrl) {
+  try {
+    const res = await fetch(`${baseUrl}/users/me`, {
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        Accept: "application/json"
+      }
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function terminalSignup(baseUrl) {
+  const rootUrl = baseUrl.replace(/\/api\/v1\/?$/, "");
+  console.log();
+  console.log(pc2.bold("Create a free Recursiv account"));
+  console.log(pc2.dim("Free tier: 1,000 API calls/day, 1 agent, 3 projects"));
+  console.log();
+  const { email } = await prompts(
+    {
+      type: "text",
+      name: "email",
+      message: "Email",
+      validate: (v) => {
+        if (!v || !v.includes("@")) return "Valid email required";
+        return true;
+      }
+    },
+    { onCancel: () => process.exit(1) }
+  );
+  const { password } = await prompts(
+    {
+      type: "password",
+      name: "password",
+      message: "Password",
+      validate: (v) => {
+        if (!v || v.length < 8) return "Password must be at least 8 characters";
+        if (!/[a-zA-Z]/.test(v) || !/[0-9]/.test(v))
+          return "Password must contain both letters and numbers";
+        return true;
+      }
+    },
+    { onCancel: () => process.exit(1) }
+  );
+  let sessionCookie = null;
+  let isNewAccount = false;
+  try {
+    const signupRes = await fetch(`${rootUrl}/api/auth/sign-up/email`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        email,
+        password,
+        name: email.split("@")[0]
+      }),
+      redirect: "manual"
+    });
+    if (signupRes.ok || signupRes.status === 302) {
+      sessionCookie = extractSessionCookie(signupRes);
+      isNewAccount = true;
+    } else if (signupRes.status === 409 || signupRes.status === 422) {
+      const signinRes = await fetch(`${rootUrl}/api/auth/sign-in/email`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ email, password }),
+        redirect: "manual"
+      });
+      if (signinRes.ok || signinRes.status === 302) {
+        sessionCookie = extractSessionCookie(signinRes);
+      } else {
+        const errBody = await signinRes.text().catch(() => "");
+        log.error(`Login failed (${signinRes.status}): ${errBody || "Invalid credentials"}`);
+        return null;
+      }
+    } else {
+      const errBody = await signupRes.text().catch(() => "");
+      log.error(`Signup failed (${signupRes.status}): ${errBody || "Unknown error"}`);
+      return null;
+    }
+  } catch (err) {
+    log.error(
+      `Could not reach ${rootUrl} \u2014 ${err instanceof Error ? err.message : "network error"}`
+    );
+    log.info(`You can create an API key manually at ${pc2.underline(DASHBOARD_URL)}`);
+    return null;
+  }
+  if (!sessionCookie) {
+    log.error("No session returned from server");
+    log.info(`Create an API key manually at ${pc2.underline(DASHBOARD_URL)}`);
+    return null;
+  }
+  if (isNewAccount) {
+    log.success("Account created");
+  } else {
+    log.success("Signed in");
+  }
+  try {
+    const keyRes = await fetch(`${baseUrl}/api-keys`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Cookie: sessionCookie
+      },
+      body: JSON.stringify({
+        name: "CLI (auto-created)",
+        scopes: DEFAULT_SCOPES
+      })
+    });
+    if (!keyRes.ok) {
+      const errBody = await keyRes.text().catch(() => "");
+      log.error(`Failed to create API key (${keyRes.status}): ${errBody}`);
+      log.info(`Create one manually at ${pc2.underline(DASHBOARD_URL)}`);
+      return null;
+    }
+    const { data } = await keyRes.json();
+    log.success(`API key created (free tier: 1,000 calls/day)`);
+    return data.key;
+  } catch (err) {
+    log.error(
+      `Failed to create API key: ${err instanceof Error ? err.message : "unknown error"}`
+    );
+    log.info(`Create one manually at ${pc2.underline(DASHBOARD_URL)}`);
+    return null;
+  }
+}
+function extractSessionCookie(res) {
+  const setCookieHeaders = "getSetCookie" in res.headers ? res.headers.getSetCookie() : [];
+  if (setCookieHeaders.length === 0) {
+    const raw = res.headers.get("set-cookie");
+    if (raw) {
+      return raw.split(",").map((c) => c.split(";")[0].trim()).join("; ");
+    }
+    return null;
+  }
+  return setCookieHeaders.map((c) => c.split(";")[0].trim()).join("; ");
+}
+async function promptApiKey() {
+  console.log(
+    pc2.dim(
+      `Get your API key from ${pc2.underline(DASHBOARD_URL)}
+Keys start with sk_live_ or sk_test_`
+    )
+  );
+  console.log();
+  const { apiKey } = await prompts(
+    {
+      type: "text",
+      name: "apiKey",
+      message: "API key (or press Enter to skip)",
+      validate: (value) => {
+        if (!value) return true;
+        if (!isValidKeyFormat(value)) {
+          return "Invalid key format. Keys start with sk_live_ or sk_test_";
+        }
+        return true;
+      }
+    },
+    { onCancel: () => process.exit(1) }
+  );
+  if (!apiKey) {
+    log.warn("No API key provided \u2014 you can add one later in .env");
+    return null;
+  }
+  return apiKey;
+}
+async function promptAndValidateApiKey(baseUrl) {
+  const apiKey = await promptApiKey();
+  if (!apiKey) return null;
+  const valid = await validateApiKey(apiKey, baseUrl);
+  if (!valid) {
+    log.warn("Could not validate API key (server unreachable or invalid key)");
+    log.info("Key saved to .env \u2014 you can update it later");
+  } else {
+    log.success("API key validated");
+  }
+  return apiKey;
+}
+async function getOrCreateApiKey(baseUrl) {
+  console.log();
+  const { method } = await prompts(
+    {
+      type: "select",
+      name: "method",
+      message: "How would you like to authenticate?",
+      choices: [
+        {
+          title: "Create a free account",
+          description: "Sign up with email + password (no browser needed)",
+          value: "signup"
+        },
+        {
+          title: "Enter an existing API key",
+          description: "Paste a key from your dashboard",
+          value: "paste"
+        },
+        {
+          title: "Skip for now",
+          description: "Add an API key later in .env",
+          value: "skip"
+        }
+      ]
+    },
+    { onCancel: () => process.exit(1) }
+  );
+  if (method === "signup") {
+    return terminalSignup(baseUrl);
+  }
+  if (method === "paste") {
+    return promptAndValidateApiKey(baseUrl);
+  }
+  log.warn("No API key \u2014 you can add one later in .env");
+  return null;
+}
+
+// src/lib/package-manager.ts
+import { existsSync } from "fs";
+import { join as join3 } from "path";
+function detectPackageManager(dir) {
+  if (existsSync(join3(dir, "bun.lockb")) || existsSync(join3(dir, "bun.lock"))) return "bun";
+  if (existsSync(join3(dir, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join3(dir, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+function detectFromUserAgent() {
+  const ua = process.env.npm_config_user_agent ?? "";
+  if (ua.startsWith("bun")) return "bun";
+  if (ua.startsWith("pnpm")) return "pnpm";
+  if (ua.startsWith("yarn")) return "yarn";
+  return "npm";
+}
+function installCommand(pm) {
+  return pm === "yarn" ? "yarn" : `${pm} install`;
+}
+function runCommand(pm, script) {
+  if (pm === "npm") return `npm run ${script}`;
+  return `${pm} ${script}`;
+}
+
+// src/templates/registry.ts
+var templates = [
+  {
+    id: "nextjs",
+    name: "Next.js + Recursiv",
+    description: "Full-stack Next.js app with feeds, chat, and agents",
+    repo: "socialdotdev/template-nextjs",
+    framework: "nextjs",
+    devCommand: "next dev",
+    devPort: 3e3,
+    recommended: true
+  },
+  {
+    id: "node",
+    name: "Node.js + Express",
+    description: "Express API server with Recursiv SDK",
+    repo: "socialdotdev/template-node",
+    framework: "express",
+    devCommand: "node --watch src/index.js",
+    devPort: 4e3
+  },
+  {
+    id: "vite",
+    name: "Vite + React",
+    description: "React SPA with social feed components",
+    repo: "socialdotdev/template-vite",
+    framework: "vite",
+    devCommand: "vite",
+    devPort: 5173
+  }
+];
+function getTemplate(id) {
+  return templates.find((t) => t.id === id);
+}
+
+// src/commands/init.ts
+import { writeFile as writeFile3 } from "fs/promises";
+async function initCommand(nameArg) {
+  banner();
+  const totalSteps = 7;
+  log.step(1, totalSteps, "Project setup");
+  let projectName;
+  if (nameArg) {
+    projectName = nameArg;
+  } else {
+    const { name } = await prompts2(
+      {
+        type: "text",
+        name: "name",
+        message: "Project name",
+        initial: "my-recursiv-app",
+        validate: (v) => v.trim() ? true : "Name is required"
+      },
+      { onCancel: () => process.exit(1) }
+    );
+    projectName = name;
+  }
+  const projectDir = resolve(process.cwd(), projectName);
+  if (existsSync2(projectDir)) {
+    log.error(`Directory ${pc3.bold(projectName)} already exists`);
+    process.exit(1);
+  }
+  log.step(2, totalSteps, "Choose a template");
+  const templateChoices = templates.map((t) => ({
+    title: t.recommended ? `${t.name} ${pc3.dim("(recommended)")}` : t.name,
+    description: t.description,
+    value: t.id
+  }));
+  const { templateId } = await prompts2(
+    {
+      type: "select",
+      name: "templateId",
+      message: "Template",
+      choices: templateChoices,
+      initial: 0
+    },
+    { onCancel: () => process.exit(1) }
+  );
+  const template = templates.find((t) => t.id === templateId);
+  log.step(3, totalSteps, "Authentication");
+  const apiKey = await getOrCreateApiKey("https://recursiv.io/api/v1");
+  log.step(4, totalSteps, "Creating project");
+  await mkdir(projectDir, { recursive: true });
+  await cloneTemplate(template, projectDir);
+  log.step(5, totalSteps, "Writing config");
+  const pm = detectFromUserAgent();
+  const config = createConfig({
+    name: projectName,
+    template: template.id,
+    framework: template.framework,
+    port: template.devPort,
+    devCommand: runCommand(pm, "dev")
+  });
+  await writeConfig(projectDir, config);
+  if (apiKey) {
+    await writeEnvFile(projectDir, apiKey);
+  }
+  const gitignorePath = resolve(projectDir, ".gitignore");
+  if (!existsSync2(gitignorePath)) {
+    await writeFile3(
+      gitignorePath,
+      ["node_modules", "dist", ".env", ".env.local", ".next", ".turbo", ""].join("\n"),
+      "utf-8"
+    );
+  }
+  log.step(6, totalSteps, "Installing dependencies");
+  const installSpinner = ora2(`Running ${pc3.bold(installCommand(pm))}...`).start();
+  try {
+    execSync(installCommand(pm), {
+      cwd: projectDir,
+      stdio: "pipe",
+      timeout: 12e4
+    });
+    installSpinner.succeed("Dependencies installed");
+  } catch {
+    installSpinner.warn("Could not install dependencies \u2014 run install manually");
+  }
+  log.step(7, totalSteps, "Initializing git");
+  try {
+    execSync("git init", { cwd: projectDir, stdio: "pipe" });
+    execSync("git add -A", { cwd: projectDir, stdio: "pipe" });
+    execSync('git commit -m "Initial commit from create-recursiv-app"', {
+      cwd: projectDir,
+      stdio: "pipe"
+    });
+    log.success("Git repository initialized");
+  } catch {
+    log.warn("Could not initialize git repository");
+  }
+  log.blank();
+  console.log(pc3.bold(pc3.green("Your Recursiv app is ready!")));
+  log.blank();
+  console.log("  Next steps:");
+  console.log();
+  console.log(`  ${pc3.dim("$")} cd ${projectName}`);
+  if (!apiKey) {
+    console.log(`  ${pc3.dim("$")} ${pc3.dim("# Add your API key to .env")}`);
+  }
+  console.log(`  ${pc3.dim("$")} ${runCommand(pm, "dev")}`);
+  log.blank();
+  console.log(pc3.dim("Docs: https://docs.recursiv.io"));
+  console.log(pc3.dim("Dashboard: https://recursiv.io/dashboard"));
+  log.blank();
+}
+
+// src/commands/dev.ts
+import { spawn } from "child_process";
+import pc4 from "picocolors";
+async function devCommand(opts) {
+  const cwd = process.cwd();
+  const config = await readConfig(cwd);
+  if (!config) {
+    log.error("No .recursiv.json found \u2014 are you in a Recursiv project?");
+    log.info(`Run ${pc4.bold("create-recursiv-app")} to create a new project`);
+    process.exit(1);
+  }
+  const apiKey = await readApiKeyFromEnv(cwd);
+  if (!apiKey) {
+    log.warn("No RECURSIV_API_KEY found in .env \u2014 API calls will fail");
+  }
+  const pm = detectPackageManager(cwd);
+  const port = opts.port ?? String(config.dev.port);
+  const devCmd = config.dev.command || runCommand(pm, "dev");
+  const env = {
+    ...process.env,
+    PORT: port
+  };
+  if (apiKey) {
+    env.RECURSIV_API_KEY = apiKey;
+    if (config.project.framework === "nextjs") {
+      env.NEXT_PUBLIC_RECURSIV_API_KEY = apiKey;
+    } else if (config.project.framework === "vite") {
+      env.VITE_RECURSIV_API_KEY = apiKey;
+    }
+  }
+  log.info(`Starting dev server on port ${pc4.bold(port)}`);
+  log.info(`Running: ${pc4.dim(devCmd)}`);
+  console.log();
+  const [cmd, ...args] = devCmd.split(" ");
+  const child = spawn(cmd, args, {
+    cwd,
+    env,
+    stdio: "inherit",
+    shell: true
+  });
+  child.on("close", (code) => {
+    process.exit(code ?? 0);
+  });
+  const cleanup = () => {
+    child.kill("SIGTERM");
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+}
+
+// src/commands/deploy.ts
+import { writeFile as writeFile4 } from "fs/promises";
+import { resolve as resolve2 } from "path";
+import pc5 from "picocolors";
+import ora3 from "ora";
+var targets = [
+  {
+    id: "vercel",
+    name: "Vercel",
+    generate: (name, framework) => ({
+      file: "vercel.json",
+      content: JSON.stringify(
+        {
+          $schema: "https://openapi.vercel.sh/vercel.json",
+          projectSettings: {
+            framework: framework === "nextjs" ? "nextjs" : framework === "vite" ? "vite" : null
+          },
+          env: {
+            RECURSIV_API_KEY: "@recursiv-api-key"
+          }
+        },
+        null,
+        2
+      )
+    })
+  },
+  {
+    id: "docker",
+    name: "Docker",
+    generate: (name, framework) => ({
+      file: "Dockerfile",
+      content: [
+        "FROM node:20-slim AS base",
+        "WORKDIR /app",
+        "COPY package*.json ./",
+        "RUN npm ci --omit=dev",
+        "COPY . .",
+        framework === "nextjs" ? "RUN npm run build" : "",
+        framework === "nextjs" ? "EXPOSE 3000" : "EXPOSE 4000",
+        framework === "nextjs" ? 'CMD ["npm", "start"]' : 'CMD ["node", "src/index.js"]',
+        ""
+      ].filter(Boolean).join("\n")
+    })
+  },
+  {
+    id: "render",
+    name: "Render",
+    generate: (name, framework) => ({
+      file: "render.yaml",
+      content: [
+        "services:",
+        `  - type: web`,
+        `    name: ${name}`,
+        `    runtime: node`,
+        `    buildCommand: npm install && npm run build`,
+        framework === "nextjs" ? "    startCommand: npm start" : "    startCommand: node src/index.js",
+        "    envVars:",
+        "      - key: RECURSIV_API_KEY",
+        "        sync: false",
+        ""
+      ].join("\n")
+    })
+  },
+  {
+    id: "railway",
+    name: "Railway",
+    generate: (name, framework) => ({
+      file: "railway.toml",
+      content: [
+        "[build]",
+        'builder = "nixpacks"',
+        "",
+        "[deploy]",
+        framework === "nextjs" ? 'startCommand = "npm start"' : 'startCommand = "node src/index.js"',
+        'healthcheckPath = "/"',
+        ""
+      ].join("\n")
+    })
+  }
+];
+async function deployCommand(target) {
+  const cwd = process.cwd();
+  const config = await readConfig(cwd);
+  if (!config) {
+    log.error("No .recursiv.json found \u2014 are you in a Recursiv project?");
+    process.exit(1);
+  }
+  if (target === "cloud") {
+    log.info("Cloud deployment via Recursiv is coming soon");
+    log.info(`For now, deploy to Vercel, Render, or Railway with ${pc5.bold("recursiv deploy <target>")}`);
+    return;
+  }
+  const deployTarget = targets.find((t) => t.id === target);
+  if (!deployTarget) {
+    log.error(`Unknown target: ${pc5.bold(target)}`);
+    log.info(`Available targets: ${targets.map((t) => t.id).join(", ")}, cloud`);
+    process.exit(1);
+  }
+  const spinner = ora3(`Generating ${deployTarget.name} config...`).start();
+  const { file, content } = deployTarget.generate(
+    config.project.name,
+    config.project.framework
+  );
+  await writeFile4(resolve2(cwd, file), content + "\n", "utf-8");
+  spinner.succeed(`Created ${pc5.bold(file)}`);
+  log.blank();
+  log.info(`Remember to set ${pc5.bold("RECURSIV_API_KEY")} in your ${deployTarget.name} environment`);
+}
+
+// src/commands/auth.ts
+import pc6 from "picocolors";
+async function loginCommand() {
+  const cwd = process.cwd();
+  const config = await readConfig(cwd);
+  const baseUrl = config?.api.baseUrl ?? "https://recursiv.io/api/v1";
+  const existing = await readApiKeyFromEnv(cwd);
+  if (existing) {
+    log.info(`Existing key found: ${pc6.dim(maskKey(existing))}`);
+    log.info("Enter a new key to replace it, or press Enter to keep it");
+  }
+  const apiKey = await getOrCreateApiKey(baseUrl);
+  if (apiKey) {
+    await updateApiKeyInEnv(cwd, apiKey);
+    log.success("API key saved to .env");
+  }
+}
+async function logoutCommand() {
+  const cwd = process.cwd();
+  const existing = await readApiKeyFromEnv(cwd);
+  if (!existing) {
+    log.info("No API key found in .env");
+    return;
+  }
+  await updateApiKeyInEnv(cwd, "");
+  log.success("API key removed from .env");
+}
+async function whoamiCommand() {
+  const cwd = process.cwd();
+  const config = await readConfig(cwd);
+  const baseUrl = config?.api.baseUrl ?? "https://recursiv.io/api/v1";
+  const apiKey = await readApiKeyFromEnv(cwd);
+  if (!apiKey) {
+    log.error("No API key found in .env");
+    log.info(`Run ${pc6.bold("recursiv auth login")} to set one`);
+    return;
+  }
+  log.info(`Key: ${pc6.dim(maskKey(apiKey))}`);
+  try {
+    const res = await fetch(`${baseUrl}/users/me`, {
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        Accept: "application/json"
+      }
+    });
+    if (!res.ok) {
+      log.error("API key is invalid or expired");
+      return;
+    }
+    const body = await res.json();
+    if (body.data.username) log.info(`User: ${pc6.bold(body.data.username)}`);
+    if (body.data.email) log.info(`Email: ${body.data.email}`);
+  } catch {
+    log.warn("Could not reach API \u2014 check your network");
+  }
+}
+function maskKey(key) {
+  if (key.length <= 12) return "****";
+  return key.slice(0, 8) + "..." + key.slice(-4);
+}
+
+// src/commands/info.ts
+import pc7 from "picocolors";
+async function infoCommand() {
+  const cwd = process.cwd();
+  const config = await readConfig(cwd);
+  if (!config) {
+    log.error("No .recursiv.json found \u2014 are you in a Recursiv project?");
+    log.info(`Run ${pc7.bold("create-recursiv-app")} to create a new project`);
+    process.exit(1);
+  }
+  const apiKey = await readApiKeyFromEnv(cwd);
+  const pm = detectPackageManager(cwd);
+  const template = getTemplate(config.project.template);
+  console.log();
+  console.log(pc7.bold("Project Info"));
+  console.log();
+  console.log(`  Name:       ${pc7.bold(config.project.name)}`);
+  console.log(`  Template:   ${template?.name ?? config.project.template}`);
+  console.log(`  Framework:  ${config.project.framework}`);
+  console.log(`  Dev port:   ${config.dev.port}`);
+  console.log(`  Dev cmd:    ${pc7.dim(config.dev.command)}`);
+  console.log(`  Pkg mgr:    ${pm}`);
+  console.log(`  API URL:    ${pc7.dim(config.api.baseUrl)}`);
+  console.log(`  API key:    ${apiKey ? pc7.green("configured") : pc7.yellow("not set")}`);
+  console.log(`  Config:     ${pc7.dim(".recursiv.json v" + config.version)}`);
+  console.log();
+  if (apiKey) {
+    try {
+      const res = await fetch(`${config.api.baseUrl}/users/me`, {
+        headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json" }
+      });
+      if (res.ok) {
+        log.success("API connection OK");
+      } else {
+        log.warn(`API returned ${res.status} \u2014 key may be invalid`);
+      }
+    } catch {
+      log.warn("Could not reach API");
+    }
+  }
+}
+
+// src/commands/brain.tsx
+import { render } from "ink";
+
+// src/ui/app.tsx
+import { useEffect, useMemo, useState } from "react";
+import { Box, Text, useApp, useInput, useStdout } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+var TABS = [
+  { key: "overview", label: "Overview" },
+  { key: "commands", label: "Commands" },
+  { key: "stack", label: "App" }
+];
+var THEME = {
+  accent: "#1FE4C6",
+  accentWarm: "#F6D47A",
+  accentCool: "#4DB6FF",
+  muted: "#6F7C8A",
+  bright: "#E9FFFA",
+  danger: "#FF6B6B"
+};
+var WORDMARK_COLORS = ["cyan", "blue", "yellow"];
+var WORDMARK_LINES = [
+  "####  ####   ###   #####  #   #",
+  "#   # #   # #   #    #    ##  #",
+  "####  ####  #####    #    # # #",
+  "#   # #  #  #   #    #    #  ##",
+  "####  #   # #   #  #####  #   #"
+];
+var HERO_LINES = [
+  "Neurons, particles, waves.",
+  "The brain behind Recursiv.",
+  "Signals in motion, products alive.",
+  "A living map of your platform.",
+  "Bioluminescent systems in sync."
+];
+var COPY = {
+  overview: `# Social.dev Brain
+A neural CLI reflection of your product surface with neurons, particles, and waves.
+
+## What it shows
+- Branded networks, communities, posts, and reactions
+- Real-time chat with human + AI agent threads
+- Tool-enabled agents with sandboxes and integrations
+- Deployments, storage buckets, and databases
+
+## Flow
+1. Create a project
+2. Run dev locally
+3. Deploy anywhere`,
+  commands: `# Command Deck
+- \`recursiv\` runs Brain when interactive
+- \`recursiv brain\`
+- \`RECURSIV_BRAIN=1 recursiv\`
+- \`RECURSIV_BRAIN=0 recursiv\`
+- \`recursiv create my-app\`
+- \`recursiv dev --port 3000\`
+- \`recursiv deploy <target>\`
+- \`recursiv auth login | logout | whoami\`
+- \`recursiv info\`
+- \`recursiv users me\`
+- \`recursiv communities list\`
+- \`recursiv posts list\`
+- \`recursiv agents list\``,
+  stack: `# App Reflection
+## Client
+- React Native + Expo
+- NativeWind + Tailwind
+
+## Backend
+- Hono + tRPC
+- Better Auth
+
+## Data + Realtime
+- PostgreSQL + Drizzle ORM
+- Kafka + Socket.IO
+
+## Agents
+- Composio + E2B + OpenRouter`
+};
+var PULSE_FRAMES = ["spark", "pulse", "sync", "bloom"];
+var DOT_FRAMES = [".", "..", "..."];
+var BAR_FRAMES = ["[~     ]", "[~~    ]", "[~~~   ]", "[ ~~~~ ]", "[  ~~~~]", "[   ~~~]", "[    ~~]", "[     ~]"];
+var AURORA_COLORS = ["#1FE4C6", "#4DB6FF", "#8AF0FF", "#F6D47A"];
+var AURORA_COLORS_DEEP = ["#0C2236", "#12314C", "#1E3A5F"];
+var QUICK_ACTIONS = [
+  "recursiv brain",
+  "create-recursiv-app my-app",
+  "recursiv dev --port 3000",
+  "recursiv users me",
+  "recursiv deploy vercel"
+];
+var HINTS = ["Tab or arrows to switch tabs.", "1/2/3 to jump instantly.", "q or Esc to exit."];
+var INTEGRATIONS = ["Composio", "E2B", "OpenRouter"];
+var INTRO_DURATION_MS = 5200;
+var INTRO_STEPS = [
+  "Igniting cortex",
+  "Mapping synapses",
+  "Charging particles",
+  "Calibrating agents",
+  "Locking signal"
+];
+var INTRO_HINTS = ["Press Space to skip", "Press q to exit"];
+function App(props) {
+  const { snapshot, animate } = props;
+  const { exit } = useApp();
+  const { stdout } = useStdout();
+  const [tab, setTab] = useState("overview");
+  const [introActive, setIntroActive] = useState(animate);
+  const columns = stdout?.columns ?? process.stdout.columns ?? 100;
+  const isNarrow = columns < 100;
+  const fieldWidth = isNarrow ? Math.max(12, columns - 6) : 26;
+  const fieldHeight = isNarrow ? 6 : 10;
+  const navWidth = isNarrow ? void 0 : 26;
+  const infoWidth = isNarrow ? void 0 : 34;
+  const pulseIndex = useTicker(animate, 700, PULSE_FRAMES.length);
+  const dotIndex = useTicker(animate, 450, DOT_FRAMES.length);
+  const heroIndex = useTicker(animate, 2200, HERO_LINES.length);
+  const barIndex = useTicker(animate, 140, BAR_FRAMES.length);
+  const sweepIndex = useTicker(animate, 60, Math.max(10, Math.min(columns - 4, 120)));
+  const scanIndex = useTicker(animate, 320, 9);
+  const introProgress = useProgress(introActive && animate, INTRO_DURATION_MS, 80);
+  const introFrame = useTicker(introActive && animate, 60, Math.max(10, columns - 6));
+  const pulse = PULSE_FRAMES[pulseIndex];
+  const dots = DOT_FRAMES[dotIndex];
+  const hero = HERO_LINES[heroIndex];
+  const bar = BAR_FRAMES[barIndex];
+  useEffect(() => {
+    if (!animate) {
+      setIntroActive(false);
+      return;
+    }
+    setIntroActive(true);
+    const id = setTimeout(() => setIntroActive(false), INTRO_DURATION_MS);
+    return () => clearTimeout(id);
+  }, [animate]);
+  useInput((input, key) => {
+    if (input === "q" || key.escape) {
+      exit();
+      return;
+    }
+    if (introActive) {
+      if (input === " " || key.return || input === "s") {
+        setIntroActive(false);
+      }
+      return;
+    }
+    if (key.tab || key.rightArrow) {
+      const next = (tabIndex(tab) + 1) % TABS.length;
+      setTab(TABS[next].key);
+      return;
+    }
+    if (key.leftArrow) {
+      const prev = (tabIndex(tab) - 1 + TABS.length) % TABS.length;
+      setTab(TABS[prev].key);
+      return;
+    }
+    if (input === "1") setTab("overview");
+    if (input === "2") setTab("commands");
+    if (input === "3") setTab("stack");
+  });
+  if (introActive) {
+    return /* @__PURE__ */ jsx(
+      IntroScreen,
+      {
+        width: columns,
+        height: Math.max(14, fieldHeight + 6),
+        progress: introProgress,
+        frame: introFrame
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [
+    /* @__PURE__ */ jsx(
+      Header,
+      {
+        hero,
+        pulse,
+        dots,
+        bar,
+        sweep: sweepIndex,
+        width: columns,
+        animate
+      }
+    ),
+    /* @__PURE__ */ jsxs(Box, { marginTop: 1, flexDirection: isNarrow ? "column" : "row", children: [
+      /* @__PURE__ */ jsx(
+        Box,
+        {
+          flexDirection: "column",
+          width: navWidth,
+          marginRight: isNarrow ? 0 : 2,
+          marginBottom: isNarrow ? 1 : 0,
+          children: /* @__PURE__ */ jsxs(Panel, { title: "Brain Map", accent: THEME.accent, borderStyle: "round", children: [
+            /* @__PURE__ */ jsx(NeuralField, { width: fieldWidth, height: fieldHeight, frame: sweepIndex, animate }),
+            /* @__PURE__ */ jsx(Text, { color: THEME.muted, children: "* neuron  o synapse  + particle  ~ wave" }),
+            /* @__PURE__ */ jsx(Divider, { width: fieldWidth }),
+            /* @__PURE__ */ jsx(SectionTitle, { label: "Navigator" }),
+            /* @__PURE__ */ jsx(Navigation, { active: tab }),
+            /* @__PURE__ */ jsx(Divider, {}),
+            /* @__PURE__ */ jsx(SectionTitle, { label: "Quick Actions" }),
+            QUICK_ACTIONS.map((item) => /* @__PURE__ */ jsxs(Text, { color: THEME.muted, children: [
+              "- ",
+              item
+            ] }, item)),
+            /* @__PURE__ */ jsx(Divider, {}),
+            /* @__PURE__ */ jsx(SectionTitle, { label: "Hints" }),
+            HINTS.map((item) => /* @__PURE__ */ jsxs(Text, { color: THEME.muted, children: [
+              "- ",
+              item
+            ] }, item))
+          ] })
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        Box,
+        {
+          flexDirection: "column",
+          flexGrow: 1,
+          marginRight: isNarrow ? 0 : 2,
+          marginBottom: isNarrow ? 1 : 0,
+          children: /* @__PURE__ */ jsx(Panel, { title: tabTitle(tab), accent: THEME.accentWarm, borderStyle: "double", children: /* @__PURE__ */ jsx(AnimatedMarkdown, { content: COPY[tab], animate }) })
+        }
+      ),
+      /* @__PURE__ */ jsx(Box, { flexDirection: "column", width: infoWidth, children: /* @__PURE__ */ jsx(Panel, { title: "Synapses", accent: THEME.accentCool, borderStyle: "round", children: /* @__PURE__ */ jsx(ProjectPanel, { snapshot, animate, dots, frame: sweepIndex, scanIndex }) }) })
+    ] }),
+    /* @__PURE__ */ jsx(Footer, { snapshot, animate })
+  ] });
+}
+function Header(props) {
+  const { hero, pulse, dots, bar, sweep, width, animate } = props;
+  const lineWidth = Math.max(32, Math.min(width - 4, 120));
+  const pulseLabel = animate ? `${pulse}${dots}` : "ready";
+  const time = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit" });
+  const wordmarkPalette = rotatePalette(WORDMARK_COLORS, sweep);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", alignItems: "center", children: [
+    /* @__PURE__ */ jsx(Wordmark, { lines: WORDMARK_LINES, palette: wordmarkPalette }),
+    /* @__PURE__ */ jsx(Text, { color: THEME.muted, children: hero }),
+    /* @__PURE__ */ jsx(Text, { color: THEME.muted, children: "by Recursiv" }),
+    /* @__PURE__ */ jsxs(Box, { marginTop: 1, flexDirection: "row", children: [
+      /* @__PURE__ */ jsx(Box, { marginRight: 2, children: /* @__PURE__ */ jsx(StatusPill, { label: "brain", value: pulseLabel, tone: THEME.accent }) }),
+      /* @__PURE__ */ jsx(Box, { marginRight: 2, children: /* @__PURE__ */ jsx(StatusPill, { label: "clock", value: time, tone: THEME.accentWarm }) }),
+      /* @__PURE__ */ jsx(StatusPill, { label: "waves", value: bar, tone: THEME.accentCool })
+    ] }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, flexDirection: "column", children: /* @__PURE__ */ jsx(Aurora, { width: lineWidth, frame: sweep }) }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(AccentLine, { width: lineWidth, frame: sweep }) })
+  ] });
+}
+function Footer(props) {
+  const { snapshot, animate } = props;
+  const projectHint = snapshot ? `${snapshot.name}` : "no project loaded";
+  const status = animate ? "brain live" : "brain ready";
+  return /* @__PURE__ */ jsxs(Box, { marginTop: 1, flexDirection: "row", justifyContent: "space-between", children: [
+    /* @__PURE__ */ jsx(Text, { color: THEME.muted, children: "Tab to switch | 1/2/3 to jump | q to quit" }),
+    /* @__PURE__ */ jsxs(Text, { color: THEME.muted, children: [
+      status,
+      " | ",
+      projectHint
+    ] })
+  ] });
+}
+function Panel(props) {
+  const { title, accent, borderStyle = "round", children } = props;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle, borderColor: accent, paddingX: 1, paddingY: 1, children: [
+    /* @__PURE__ */ jsx(Text, { color: accent, children: title }),
+    /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: 1, children })
+  ] });
+}
+function SectionTitle(props) {
+  return /* @__PURE__ */ jsx(Text, { color: THEME.accentWarm, children: props.label });
+}
+function Navigation(props) {
+  const { active } = props;
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: TABS.map((tab, index) => {
+    const isActive = tab.key === active;
+    const marker = isActive ? ">" : " ";
+    const color = isActive ? THEME.accent : THEME.muted;
+    return /* @__PURE__ */ jsxs(Text, { color, children: [
+      marker,
+      " ",
+      index + 1,
+      ". ",
+      tab.label
+    ] }, tab.key);
+  }) });
+}
+function NeuralField(props) {
+  const { width, height, frame, animate } = props;
+  const lines = useMemo(() => buildNeuralField(width, height, animate ? frame : 0), [width, height, frame, animate]);
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: lines.map((line, index) => {
+    const tone = line.includes("~") || line.includes("*") || line.includes("+") || line.includes("o") || line.includes("O") ? THEME.accentCool : THEME.muted;
+    return /* @__PURE__ */ jsx(Text, { color: tone, children: line }, index);
+  }) });
+}
+function ProjectPanel(props) {
+  const { snapshot, animate, dots, frame, scanIndex } = props;
+  if (!snapshot) {
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Text, { color: THEME.accentWarm, children: "Not in a Recursiv project." }),
+      /* @__PURE__ */ jsx(Text, { color: THEME.muted, children: "Run create-recursiv-app to start." })
+    ] });
+  }
+  const status = animate ? `firing${dots}` : "quiet";
+  const apiStatus = snapshot.apiKeyConfigured ? "linked" : "missing";
+  const apiTone = snapshot.apiKeyConfigured ? THEME.accentCool : THEME.danger;
+  const meter = buildPulseMeter(animate ? frame : 0, 16);
+  const fields = [
+    { label: "Name", value: snapshot.name },
+    { label: "Template", value: snapshot.template },
+    { label: "Framework", value: snapshot.framework },
+    { label: "Dev port", value: String(snapshot.port) },
+    { label: "Pkg mgr", value: snapshot.packageManager },
+    { label: "API base", value: snapshot.apiBaseUrl, dim: true },
+    { label: "API key", value: apiStatus, tone: apiTone },
+    { label: "Status", value: status, tone: THEME.accent },
+    { label: "Pulse", value: meter, tone: THEME.accentWarm }
+  ];
+  const activeIndex = fields.length > 0 ? scanIndex % fields.length : 0;
+  const scanBar = buildScanBar(activeIndex, 18);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    fields.map((field, index) => {
+      const distance = Math.min(
+        Math.abs(index - activeIndex),
+        fields.length - Math.abs(index - activeIndex)
+      );
+      const glow = animate && distance === 0 ? "strong" : animate && distance === 1 ? "soft" : "none";
+      return /* @__PURE__ */ jsx(
+        Field,
+        {
+          label: field.label,
+          value: field.value,
+          dim: field.dim,
+          tone: field.tone,
+          glow
+        },
+        field.label
+      );
+    }),
+    /* @__PURE__ */ jsxs(Text, { color: THEME.accentCool, children: [
+      "Neural scan ",
+      scanBar
+    ] }),
+    /* @__PURE__ */ jsx(Divider, {}),
+    /* @__PURE__ */ jsx(SectionTitle, { label: "Integrations" }),
+    INTEGRATIONS.map((item) => /* @__PURE__ */ jsxs(Text, { color: THEME.muted, children: [
+      "- ",
+      item
+    ] }, item)),
+    /* @__PURE__ */ jsx(Divider, {}),
+    /* @__PURE__ */ jsx(Text, { color: THEME.muted, children: "Dev cmd:" }),
+    /* @__PURE__ */ jsx(Text, { color: THEME.muted, children: snapshot.devCommand })
+  ] });
+}
+function Field(props) {
+  const { label, value, dim, tone, glow = "none" } = props;
+  const marker = glow === "strong" ? ">" : glow === "soft" ? "-" : " ";
+  const paddedLabel = `${marker} ${label.padEnd(9, " ")}`;
+  const labelColor = glow === "strong" ? THEME.accentWarm : glow === "soft" ? THEME.accent : THEME.muted;
+  const valueColor = glow === "strong" ? THEME.bright : glow === "soft" ? THEME.accentCool : tone ?? (dim ? THEME.muted : void 0);
+  return /* @__PURE__ */ jsxs(Text, { children: [
+    /* @__PURE__ */ jsx(Text, { color: labelColor, children: paddedLabel }),
+    /* @__PURE__ */ jsx(Text, { color: valueColor, children: value })
+  ] });
+}
+function StatusPill(props) {
+  const { label, value, tone } = props;
+  return /* @__PURE__ */ jsxs(Text, { color: tone, children: [
+    "[",
+    label,
+    ": ",
+    value,
+    "]"
+  ] });
+}
+function Wordmark(props) {
+  const { lines, palette } = props;
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", alignItems: "center", children: lines.map((line, index) => /* @__PURE__ */ jsx(Text, { color: palette[index % palette.length] ?? THEME.accent, children: line }, index)) });
+}
+function ColorLine(props) {
+  return /* @__PURE__ */ jsx(Text, { color: props.color, children: props.text });
+}
+function Aurora(props) {
+  const { width, frame } = props;
+  const lineWidth = Math.max(18, width);
+  const lineA = buildAuroraLine(lineWidth, frame, 0);
+  const lineB = buildInterferenceLine(lineWidth, frame + 7, 1);
+  const lineC = buildAuroraLine(lineWidth, frame + 13, 2);
+  const lineD = buildNeuronHalo(lineWidth, frame);
+  const palette = rotatePalette(AURORA_COLORS, frame);
+  const deepPalette = rotatePalette(AURORA_COLORS_DEEP, frame);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(ColorLine, { text: lineA, color: palette[0] }),
+    /* @__PURE__ */ jsx(ColorLine, { text: lineB, color: deepPalette[0] }),
+    /* @__PURE__ */ jsx(ColorLine, { text: lineC, color: palette[1] ?? palette[0] }),
+    /* @__PURE__ */ jsx(ColorLine, { text: lineD, color: palette[2] ?? palette[0] })
+  ] });
+}
+function Divider(props = {}) {
+  const { width } = props;
+  const lineWidth = Math.max(12, Math.min(32, width ?? 22));
+  return /* @__PURE__ */ jsx(Text, { color: THEME.muted, children: "-".repeat(lineWidth) });
+}
+function AccentLine(props) {
+  const { width, frame } = props;
+  const lineWidth = Math.max(10, width);
+  const head = Math.min(frame % lineWidth, lineWidth - 1);
+  const left = "-".repeat(head);
+  const right = "-".repeat(Math.max(0, lineWidth - head - 1));
+  return /* @__PURE__ */ jsxs(Text, { color: THEME.muted, children: [
+    left,
+    /* @__PURE__ */ jsx(Text, { color: THEME.accent, children: "*" }),
+    right
+  ] });
+}
+function AnimatedMarkdown(props) {
+  const { content, animate } = props;
+  const safe = useMemo(() => content.replace(/\r\n/g, "\n"), [content]);
+  const lines = useMemo(() => safe.split("\n"), [safe]);
+  const [visibleLines, setVisibleLines] = useState(animate ? 1 : lines.length);
+  useEffect(() => {
+    if (!animate) {
+      setVisibleLines(lines.length);
+      return;
+    }
+    setVisibleLines(1);
+    const id = setInterval(() => {
+      setVisibleLines((current) => current >= lines.length ? current : current + 1);
+    }, 55);
+    return () => clearInterval(id);
+  }, [animate, lines.length, safe]);
+  const sliceCount = Math.max(1, visibleLines);
+  const text = animate ? lines.slice(0, sliceCount).join("\n") : safe;
+  return /* @__PURE__ */ jsx(MarkdownBlock, { content: text });
+}
+function MarkdownBlock(props) {
+  const lines = props.content.split("\n");
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: lines.map((line, index) => {
+    if (line.startsWith("### ")) {
+      return /* @__PURE__ */ jsx(Text, { color: THEME.accentCool, children: line.slice(4) }, index);
+    }
+    if (line.startsWith("## ")) {
+      return /* @__PURE__ */ jsx(Text, { color: THEME.accentWarm, children: line.slice(3) }, index);
+    }
+    if (line.startsWith("# ")) {
+      return /* @__PURE__ */ jsx(Text, { color: THEME.accent, children: line.slice(2) }, index);
+    }
+    if (line.startsWith("- ")) {
+      return /* @__PURE__ */ jsxs(Text, { color: THEME.muted, children: [
+        "- ",
+        line.slice(2)
+      ] }, index);
+    }
+    if (/^\d+\.\s/.test(line)) {
+      return /* @__PURE__ */ jsx(Text, { color: THEME.muted, children: line }, index);
+    }
+    if (line.trim().length === 0) {
+      return /* @__PURE__ */ jsx(Text, { children: " " }, index);
+    }
+    return /* @__PURE__ */ jsx(Text, { color: THEME.bright, children: line }, index);
+  }) });
+}
+function useTicker(animate, intervalMs, length) {
+  const [tick, setTick] = useState(0);
+  useEffect(() => {
+    if (!animate || length <= 0) {
+      setTick(0);
+      return;
+    }
+    const id = setInterval(() => {
+      setTick((current) => (current + 1) % length);
+    }, intervalMs);
+    return () => clearInterval(id);
+  }, [animate, intervalMs, length]);
+  return tick;
+}
+function tabIndex(tab) {
+  return TABS.findIndex((item) => item.key === tab);
+}
+function tabTitle(tab) {
+  const active = TABS.find((item) => item.key === tab);
+  return active ? active.label : "Overview";
+}
+function buildNeuralField(width, height, frame) {
+  const safeWidth = Math.max(8, width);
+  const safeHeight = Math.max(4, height);
+  const grid = Array.from({ length: safeHeight }, () => Array(safeWidth).fill(" "));
+  const phase = Math.floor(frame / 6);
+  const rng = makeRng(phase * 109 + 97);
+  const nodes = [];
+  const place = (x, y, char, priority = 0) => {
+    if (x < 0 || x >= safeWidth || y < 0 || y >= safeHeight) return;
+    const current = grid[y][x];
+    const currentPriority = current === "*" || current === "O" ? 3 : current === "o" ? 2 : current === "~" ? 1 : 0;
+    if (priority >= currentPriority || current === " ") {
+      grid[y][x] = char;
+    }
+  };
+  for (let y = 0; y < safeHeight; y += 1) {
+    for (let x = 0; x < safeWidth; x += 1) {
+      const roll = rng();
+      if (roll < 0.018) {
+        grid[y][x] = "*";
+        nodes.push({ x, y });
+      } else if (roll < 0.04) {
+        grid[y][x] = "o";
+        nodes.push({ x, y });
+      } else if (roll < 0.12) {
+        grid[y][x] = ".";
+      }
+    }
+  }
+  const mid = Math.floor(safeHeight / 2);
+  const amp = Math.max(1, Math.floor(safeHeight / 3));
+  for (let x = 0; x < safeWidth; x += 1) {
+    const y = Math.round(mid + Math.sin((x + frame * 0.6) / 3) * amp);
+    place(x, y, "~", 1);
+    if ((x + frame) % 11 === 0) place(x, y, "*", 3);
+  }
+  const mid2 = Math.floor(safeHeight / 3);
+  const amp2 = Math.max(1, Math.floor(safeHeight / 4));
+  for (let x = 0; x < safeWidth; x += 1) {
+    const y = Math.round(mid2 + Math.sin((x + frame * 0.4) / 2.6) * amp2);
+    place(x, y, "~", 1);
+    if ((x + frame * 2) % 17 === 0) place(x, y, "o", 2);
+  }
+  const particleCount = Math.max(2, Math.floor(safeWidth / 12));
+  for (let i = 0; i < particleCount; i += 1) {
+    const particleX = (frame * (i + 2) + i * 7) % safeWidth;
+    const particleY = (frame * (i + 3) + i * 5) % safeHeight;
+    place(particleX, particleY, "+", 2);
+  }
+  nodes.forEach((node) => {
+    if (rng() < 0.35) {
+      const length = 2 + Math.floor(rng() * 6);
+      const drift = rng() < 0.5 ? 1 : -1;
+      for (let step = 1; step <= length; step += 1) {
+        const x = node.x + step;
+        const y = node.y + (rng() < 0.3 ? drift : 0);
+        place(x, y, rng() < 0.5 ? "-" : "=", 0);
+      }
+    }
+    if ((node.x + frame) % 14 === 0) {
+      place(node.x, node.y, "O", 3);
+    }
+  });
+  return grid.map((row) => row.join(""));
+}
+function buildAuroraLine(width, frame, offset) {
+  const safeWidth = Math.max(10, width);
+  const chars = [" ", " ", ".", ":", "-", "=", "+", "*"];
+  let line = "";
+  for (let x = 0; x < safeWidth; x += 1) {
+    const phase = (x + frame * 0.9 + offset * 7) / 4;
+    const wave = Math.sin(phase) * 0.6 + Math.sin(phase / 2 + offset) * 0.4 + 1;
+    const normalized = Math.max(0, Math.min(1, wave / 2));
+    const idx = Math.min(chars.length - 1, Math.floor(normalized * (chars.length - 1)));
+    line += chars[idx];
+  }
+  return line;
+}
+function buildInterferenceLine(width, frame, offset) {
+  const safeWidth = Math.max(10, width);
+  const chars = [" ", ".", ":", "-", "=", "+", "*", "#"];
+  let line = "";
+  for (let x = 0; x < safeWidth; x += 1) {
+    const waveA = Math.sin((x + frame * 0.6 + offset * 5) / 3);
+    const waveB = Math.sin((x * 0.6 + frame * 0.3) / 2.1);
+    const waveC = Math.sin((x * 1.2 + frame * 0.9) / 4.6);
+    const mix = (waveA + waveB + waveC + 3) / 6;
+    const idx = Math.min(chars.length - 1, Math.floor(mix * (chars.length - 1)));
+    line += chars[idx];
+  }
+  return line;
+}
+function buildNeuronHalo(width, frame) {
+  const safeWidth = Math.max(10, width);
+  const rng = makeRng((Math.floor(frame / 4) + 11) * 233);
+  let line = "";
+  for (let x = 0; x < safeWidth; x += 1) {
+    const roll = rng();
+    if (roll < 0.04) line += "*";
+    else if (roll < 0.08) line += "o";
+    else if (roll < 0.11) line += ".";
+    else line += " ";
+  }
+  return line;
+}
+function buildPulseMeter(frame, width) {
+  const safeWidth = Math.max(8, width);
+  const head = frame % safeWidth;
+  let line = "";
+  for (let i = 0; i < safeWidth; i += 1) {
+    if (i === head) {
+      line += "*";
+    } else if (Math.abs(i - head) === 1) {
+      line += "+";
+    } else if ((i + frame) % 5 === 0) {
+      line += "-";
+    } else {
+      line += ".";
+    }
+  }
+  return line;
+}
+function buildScanBar(position, width) {
+  const safeWidth = Math.max(8, width);
+  if (position < 0) return "[" + ".".repeat(safeWidth) + "]";
+  const head = position % safeWidth;
+  let line = "";
+  for (let i = 0; i < safeWidth; i += 1) {
+    if (i === head) line += ">";
+    else if (Math.abs(i - head) === 1) line += "=";
+    else line += ".";
+  }
+  return `[${line}]`;
+}
+function makeRng(seed) {
+  let state = seed >>> 0;
+  return () => {
+    state = state * 1664525 + 1013904223 >>> 0;
+    return state / 4294967295;
+  };
+}
+function rotatePalette(palette, frame) {
+  if (palette.length === 0) return palette;
+  const offset = frame % palette.length;
+  return [...palette.slice(offset), ...palette.slice(0, offset)];
+}
+function useProgress(active, durationMs, stepMs) {
+  const [progress, setProgress] = useState(active ? 0 : 1);
+  useEffect(() => {
+    if (!active) {
+      setProgress(1);
+      return;
+    }
+    setProgress(0);
+    const start = Date.now();
+    const id = setInterval(() => {
+      const value = Math.min(1, (Date.now() - start) / durationMs);
+      setProgress(value);
+      if (value >= 1) clearInterval(id);
+    }, stepMs);
+    return () => clearInterval(id);
+  }, [active, durationMs, stepMs]);
+  return progress;
+}
+function IntroScreen(props) {
+  const { width, height, progress, frame } = props;
+  const fieldWidth = Math.max(24, width - 6);
+  const fieldHeight = Math.max(10, Math.min(14, height));
+  const steps = INTRO_STEPS.map((label, index) => ({
+    label,
+    done: progress >= (index + 1) / INTRO_STEPS.length
+  }));
+  const bar = buildProgressBar(progress, Math.max(16, Math.min(34, Math.floor(width / 3))));
+  const palette = rotatePalette(WORDMARK_COLORS, frame);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [
+    /* @__PURE__ */ jsxs(Box, { flexDirection: "column", alignItems: "center", children: [
+      /* @__PURE__ */ jsx(Wordmark, { lines: WORDMARK_LINES, palette }),
+      /* @__PURE__ */ jsx(Text, { color: THEME.muted, children: "Neural ignition sequence" })
+    ] }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, flexDirection: "column", alignItems: "center", children: /* @__PURE__ */ jsx(ColorLine, { text: bar, color: THEME.accentWarm }) }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, flexDirection: "column", children: steps.map((step, index) => /* @__PURE__ */ jsxs(Text, { color: step.done ? THEME.accent : THEME.muted, children: [
+      "[",
+      step.done ? "x" : " ",
+      "] ",
+      step.label
+    ] }, index)) }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(NeuralField, { width: fieldWidth, height: fieldHeight, frame, animate: true }) }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: INTRO_HINTS.map((hint) => /* @__PURE__ */ jsx(Text, { color: THEME.muted, children: hint }, hint)) })
+  ] });
+}
+function buildProgressBar(progress, width) {
+  const safeWidth = Math.max(10, width);
+  const filled = Math.round(progress * safeWidth);
+  const left = "=".repeat(filled);
+  const right = ".".repeat(Math.max(0, safeWidth - filled));
+  return `[${left}${right}]`;
+}
+
+// src/commands/brain.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+async function brainCommand(opts) {
+  const cwd = process.cwd();
+  const config = await readConfig(cwd);
+  const apiKey = await readApiKeyFromEnv(cwd);
+  const packageManager = detectPackageManager(cwd);
+  const snapshot = config ? {
+    name: config.project.name,
+    template: config.project.template,
+    framework: config.project.framework,
+    port: config.dev.port,
+    devCommand: config.dev.command,
+    apiBaseUrl: config.api.baseUrl,
+    apiKeyConfigured: Boolean(apiKey),
+    packageManager
+  } : null;
+  const app = render(/* @__PURE__ */ jsx2(App, { snapshot, animate: opts.anim !== false }));
+  await app.waitUntilExit();
+}
+
+// src/commands/studio.tsx
+async function studioCommand(opts) {
+  await brainCommand(opts);
+}
+
+// src/commands/api.ts
+import pc9 from "picocolors";
+
+// src/lib/api.ts
+import pc8 from "picocolors";
+async function getApiContext(cwd) {
+  const config = await readConfig(cwd);
+  const apiKey = await readApiKeyFromEnv(cwd);
+  if (!apiKey) {
+    log.error("No API key configured.");
+    log.info(`Run ${pc8.bold("recursiv auth login")} to set your key.`);
+    process.exit(1);
+  }
+  return {
+    baseUrl: config?.api.baseUrl ?? "https://recursiv.io/api/v1",
+    apiKey
+  };
+}
+async function apiRequest(ctx, opts) {
+  const url = new URL(opts.path, ctx.baseUrl.endsWith("/") ? ctx.baseUrl : ctx.baseUrl + "/");
+  if (opts.query) {
+    Object.entries(opts.query).forEach(([key, value]) => {
+      if (value === void 0 || value === null || value === "") return;
+      url.searchParams.set(key, String(value));
+    });
+  }
+  const res = await fetch(url, {
+    method: opts.method,
+    headers: {
+      Authorization: `Bearer ${ctx.apiKey}`,
+      Accept: "application/json",
+      ...opts.body ? { "Content-Type": "application/json" } : {}
+    },
+    body: opts.body ? JSON.stringify(opts.body) : void 0
+  });
+  const text = await res.text();
+  const payload = safeJson(text);
+  if (!res.ok) {
+    const message = payload?.error?.message || payload?.message || `Request failed (${res.status} ${res.statusText})`;
+    throw new Error(message);
+  }
+  return payload ?? {};
+}
+function safeJson(text) {
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/api.ts
+async function usersMeCommand(opts) {
+  const ctx = await getApiContext(process.cwd());
+  const res = await apiRequest(ctx, { method: "GET", path: "users/me" });
+  output(res, opts.json, (data) => {
+    log.blank();
+    console.log(pc9.bold("User"));
+    console.log(`  ${pc9.dim("id")}: ${data.id}`);
+    console.log(`  ${pc9.dim("name")}: ${data.name ?? "-"}`);
+    console.log(`  ${pc9.dim("username")}: ${data.username ?? "-"}`);
+    console.log(`  ${pc9.dim("email")}: ${data.email ?? "-"}`);
+    console.log(`  ${pc9.dim("followers")}: ${data.followers_count ?? 0}`);
+    console.log(`  ${pc9.dim("following")}: ${data.following_count ?? 0}`);
+    console.log(`  ${pc9.dim("posts")}: ${data.posts_count ?? 0}`);
+    log.blank();
+  });
+}
+async function communitiesListCommand(opts) {
+  const ctx = await getApiContext(process.cwd());
+  const res = await apiRequest(ctx, {
+    method: "GET",
+    path: "communities",
+    query: {
+      limit: opts.limit,
+      offset: opts.offset
+    }
+  });
+  output(res, opts.json, (data, meta) => {
+    log.blank();
+    console.log(pc9.bold("Communities"));
+    data.forEach((comm) => {
+      const name = pc9.bold(comm.name);
+      const slug = comm.slug ? pc9.dim(`/${comm.slug}`) : "";
+      const members = pc9.dim(`members ${comm.member_count ?? 0}`);
+      console.log(`  ${name} ${slug} ${members}`);
+      if (comm.description) console.log(`    ${pc9.dim(comm.description)}`);
+    });
+    printMeta(meta);
+  });
+}
+async function communitiesCreateCommand(opts) {
+  if (!opts.name || !opts.slug) {
+    log.error("Missing required flags: --name and --slug");
+    process.exit(1);
+  }
+  const ctx = await getApiContext(process.cwd());
+  const res = await apiRequest(ctx, {
+    method: "POST",
+    path: "communities",
+    body: {
+      name: opts.name,
+      slug: opts.slug,
+      description: opts.description,
+      privacy: opts.privacy ?? "public"
+    }
+  });
+  output(res, opts.json, (data) => {
+    log.success(`Community created: ${pc9.bold(data.name)} (${data.id})`);
+  });
+}
+async function postsListCommand(opts) {
+  const ctx = await getApiContext(process.cwd());
+  const res = await apiRequest(ctx, {
+    method: "GET",
+    path: "posts",
+    query: {
+      limit: opts.limit,
+      offset: opts.offset,
+      community_id: opts.communityId,
+      author_id: opts.authorId
+    }
+  });
+  output(res, opts.json, (data, meta) => {
+    log.blank();
+    console.log(pc9.bold("Posts"));
+    data.forEach((post) => {
+      const author = post.author?.username ? `@${post.author.username}` : "unknown";
+      const content = truncate(post.content ?? "", 100);
+      console.log(`  ${pc9.bold(author)} ${pc9.dim(post.id)}`);
+      console.log(`    ${content}`);
+    });
+    printMeta(meta);
+  });
+}
+async function postsCreateCommand(opts) {
+  if (!opts.content) {
+    log.error("Missing required flag: --content");
+    process.exit(1);
+  }
+  const ctx = await getApiContext(process.cwd());
+  const tagIds = opts.tagIds ? opts.tagIds.split(",").map((id) => id.trim()).filter(Boolean) : void 0;
+  const res = await apiRequest(ctx, {
+    method: "POST",
+    path: "posts",
+    body: {
+      content: opts.content,
+      content_format: opts.markdown ? "markdown" : "plain",
+      community_id: opts.communityId,
+      organization_id: opts.organizationId,
+      reply_to_id: opts.replyToId,
+      tag_ids: tagIds
+    }
+  });
+  output(res, opts.json, (data) => {
+    log.success(`Post created: ${pc9.dim(data.id)}`);
+  });
+}
+async function projectsListCommand(opts) {
+  const ctx = await getApiContext(process.cwd());
+  const res = await apiRequest(ctx, {
+    method: "GET",
+    path: "projects",
+    query: {
+      limit: opts.limit,
+      offset: opts.offset,
+      organization_id: opts.organizationId
+    }
+  });
+  output(res, opts.json, (data, meta) => {
+    log.blank();
+    console.log(pc9.bold("Projects"));
+    data.forEach((proj) => {
+      const name = pc9.bold(proj.name);
+      const slug = proj.slug ? pc9.dim(`/${proj.slug}`) : "";
+      const org = proj.organization?.slug ? pc9.dim(`org ${proj.organization.slug}`) : "";
+      console.log(`  ${name} ${slug} ${org}`);
+    });
+    printMeta(meta);
+  });
+}
+async function projectsCreateCommand(opts) {
+  if (!opts.organizationId || !opts.name) {
+    log.error("Missing required flags: --org and --name");
+    process.exit(1);
+  }
+  const ctx = await getApiContext(process.cwd());
+  const res = await apiRequest(ctx, {
+    method: "POST",
+    path: "projects",
+    body: {
+      organization_id: opts.organizationId,
+      name: opts.name,
+      slug: opts.slug,
+      repo_url: opts.repoUrl,
+      template_source: opts.templateSource ?? "default",
+      custom_template_url: opts.templateUrl
+    }
+  });
+  output(res, opts.json, (data) => {
+    log.success(`Project created: ${pc9.bold(data.name)} (${data.id})`);
+  });
+}
+async function agentsListCommand(opts) {
+  const ctx = await getApiContext(process.cwd());
+  const res = await apiRequest(ctx, {
+    method: "GET",
+    path: "agents",
+    query: {
+      limit: opts.limit,
+      offset: opts.offset
+    }
+  });
+  output(res, opts.json, (data, meta) => {
+    log.blank();
+    console.log(pc9.bold("Agents"));
+    data.forEach((agent) => {
+      const name = pc9.bold(agent.name);
+      const handle = agent.username ? pc9.dim(`@${agent.username}`) : "";
+      const model = agent.model ? pc9.dim(agent.model) : "";
+      console.log(`  ${name} ${handle} ${model}`);
+    });
+    printMeta(meta);
+  });
+}
+async function agentsCreateCommand(opts) {
+  if (!opts.name || !opts.username) {
+    log.error("Missing required flags: --name and --username");
+    process.exit(1);
+  }
+  const ctx = await getApiContext(process.cwd());
+  const res = await apiRequest(ctx, {
+    method: "POST",
+    path: "agents",
+    body: {
+      name: opts.name,
+      username: opts.username,
+      bio: opts.bio,
+      model: opts.model,
+      system_prompt: opts.systemPrompt,
+      social_mode: opts.socialMode,
+      post_frequency: opts.postFrequency,
+      tool_mode: opts.toolMode,
+      daily_request_limit: opts.dailyRequestLimit ? Number(opts.dailyRequestLimit) : void 0,
+      organization_id: opts.organizationId
+    }
+  });
+  output(res, opts.json, (data) => {
+    log.success(`Agent created: ${pc9.bold(data.name)} (${data.id})`);
+  });
+}
+function output(res, json, render2) {
+  if (json) {
+    console.log(JSON.stringify(res, null, 2));
+    return;
+  }
+  render2(res.data, res.meta);
+}
+function printMeta(meta) {
+  if (!meta) return;
+  log.blank();
+  console.log(pc9.dim(`limit ${meta.limit ?? 0} offset ${meta.offset ?? 0} has_more ${meta.has_more ?? false}`));
+  log.blank();
+}
+function truncate(value, max) {
+  if (value.length <= max) return value;
+  return value.slice(0, max - 1) + "\u2026";
+}
+
+// src/bin/recursiv.ts
+var program = new Command();
+program.name("recursiv").description("Recursiv CLI \u2014 build and ship apps with AI").version("0.1.0");
+program.command("create [name]").description("Create a new Recursiv application").action(async (name) => {
+  try {
+    await initCommand(name);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+program.command("dev").description("Start the development server").option("-p, --port <port>", "port to run on").action(async (opts) => {
+  try {
+    await devCommand(opts);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+program.command("deploy <target>").description("Generate deployment config (vercel, docker, render, railway, cloud)").action(async (target) => {
+  try {
+    await deployCommand(target);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+var auth = program.command("auth").description("Manage API authentication");
+auth.command("login").description("Set or update your API key").action(async () => {
+  try {
+    await loginCommand();
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+auth.command("logout").description("Remove API key from .env").action(async () => {
+  try {
+    await logoutCommand();
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+auth.command("whoami").description("Show current authenticated user").action(async () => {
+  try {
+    await whoamiCommand();
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+program.command("info").description("Display project information").action(async () => {
+  try {
+    await infoCommand();
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+var users = program.command("users").description("Users API");
+users.command("me").description("Show current authenticated user").option("--json", "Output JSON").action(async (opts) => {
+  try {
+    await usersMeCommand(opts);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+var communities = program.command("communities").description("Communities API");
+communities.command("list").description("List communities").option("--limit <limit>", "number of results").option("--offset <offset>", "pagination offset").option("--json", "Output JSON").action(async (opts) => {
+  try {
+    await communitiesListCommand(opts);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+communities.command("create").description("Create a community").requiredOption("--name <name>", "community name").requiredOption("--slug <slug>", "community slug").option("--description <description>", "description").option("--privacy <privacy>", "public | private | hidden", "public").option("--json", "Output JSON").action(async (opts) => {
+  try {
+    await communitiesCreateCommand(opts);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+var posts = program.command("posts").description("Posts API");
+posts.command("list").description("List posts").option("--community-id <id>", "filter by community").option("--author-id <id>", "filter by author").option("--limit <limit>", "number of results").option("--offset <offset>", "pagination offset").option("--json", "Output JSON").action(async (opts) => {
+  try {
+    await postsListCommand(opts);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+posts.command("create").description("Create a post").requiredOption("--content <content>", "post content").option("--markdown", "content is markdown").option("--community-id <id>", "community id").option("--organization-id <id>", "organization id").option("--reply-to-id <id>", "reply to post id").option("--tag-ids <ids>", "comma-separated tag ids").option("--json", "Output JSON").action(async (opts) => {
+  try {
+    await postsCreateCommand(opts);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+var projects = program.command("projects").description("Projects API");
+projects.command("list").description("List projects").option("--org <id>", "organization id").option("--limit <limit>", "number of results").option("--offset <offset>", "pagination offset").option("--json", "Output JSON").action(async (opts) => {
+  try {
+    await projectsListCommand({
+      organizationId: opts.org,
+      limit: opts.limit,
+      offset: opts.offset,
+      json: opts.json
+    });
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+projects.command("create").description("Create a project").requiredOption("--org <id>", "organization id").requiredOption("--name <name>", "project name").option("--slug <slug>", "project slug").option("--repo <url>", "repo URL").option("--template <source>", "default | custom", "default").option("--template-url <url>", "custom template URL").option("--json", "Output JSON").action(async (opts) => {
+  try {
+    await projectsCreateCommand({
+      organizationId: opts.org,
+      name: opts.name,
+      slug: opts.slug,
+      repoUrl: opts.repo,
+      templateSource: opts.template,
+      templateUrl: opts.templateUrl,
+      json: opts.json
+    });
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+var agents = program.command("agents").description("Agents API");
+agents.command("list").description("List agents").option("--limit <limit>", "number of results").option("--offset <offset>", "pagination offset").option("--json", "Output JSON").action(async (opts) => {
+  try {
+    await agentsListCommand(opts);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+agents.command("create").description("Create an AI agent").requiredOption("--name <name>", "agent name").requiredOption("--username <username>", "agent username").option("--bio <bio>", "agent bio").option("--model <model>", "model id").option("--system-prompt <prompt>", "system prompt").option("--social-mode <mode>", "chat_only | chat_post").option("--post-frequency <freq>", "never | light | medium | heavy").option("--tool-mode <mode>", "chat_only | permission | autonomous").option("--daily-request-limit <n>", "daily request limit").option("--org <id>", "organization id").option("--json", "Output JSON").action(async (opts) => {
+  try {
+    await agentsCreateCommand({
+      name: opts.name,
+      username: opts.username,
+      bio: opts.bio,
+      model: opts.model,
+      systemPrompt: opts.systemPrompt,
+      socialMode: opts.socialMode,
+      postFrequency: opts.postFrequency,
+      toolMode: opts.toolMode,
+      dailyRequestLimit: opts.dailyRequestLimit,
+      organizationId: opts.org,
+      json: opts.json
+    });
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+program.command("brain").description("Launch the interactive Recursiv brain").option("--no-anim", "Disable animations").action(async (opts) => {
+  try {
+    await brainCommand(opts);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+program.command("studio").description("Legacy alias for brain").option("--no-anim", "Disable animations").action(async (opts) => {
+  try {
+    await studioCommand(opts);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+async function runDefaultBrain() {
+  try {
+    await brainCommand({});
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+}
+function shouldAutoLaunchBrain(args) {
+  if (process.env.RECURSIV_BRAIN === "1") return true;
+  if (process.env.RECURSIV_BRAIN === "0") return false;
+  if (process.env.RECURSIV_STUDIO === "1") return true;
+  if (process.env.RECURSIV_STUDIO === "0") return false;
+  if (args.length > 0) return false;
+  if (!process.stdout.isTTY) return false;
+  if (process.env.CI) return false;
+  return true;
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.includes("--brain") || args.includes("--studio")) {
+    const filtered = args.filter((arg) => arg !== "--brain" && arg !== "--studio");
+    process.argv = [process.argv[0], process.argv[1], ...filtered];
+    const noAnim = filtered.includes("--no-anim");
+    await brainCommand({ anim: !noAnim });
+    return;
+  }
+  if (shouldAutoLaunchBrain(args)) {
+    await runDefaultBrain();
+    return;
+  }
+  program.parse();
+}
+void main();
+//# sourceMappingURL=recursiv.js.map