@riventa/cli 1.1.2 → 1.2.0

package/dist/repl.js

@@ -0,0 +1,1351 @@
+// src/repl.ts
+import { createInterface } from "readline";
+import chalk16 from "chalk";
+
+// src/utils/api.ts
+import Conf from "conf";
+import chalk from "chalk";
+var config = new Conf({ projectName: "riventa-cli" });
+function getApiKey() {
+  return config.get("apiKey");
+}
+function getProjectId() {
+  return config.get("projectId");
+}
+function getBaseUrl() {
+  return config.get("baseUrl") || "https://riventa.dev/api";
+}
+function setConfig(key, value) {
+  config.set(key, value);
+}
+function getConfig(key) {
+  return config.get(key);
+}
+function getAllConfig() {
+  return config.store;
+}
+function requireAuth() {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    console.log(chalk.red("\n  Not authenticated. Run `riventa login` first.\n"));
+    process.exit(1);
+  }
+  return apiKey;
+}
+function requireProject() {
+  const projectId = getProjectId();
+  if (!projectId) {
+    console.log(chalk.red("\n  No project configured. Run `riventa init` first.\n"));
+    process.exit(1);
+  }
+  return projectId;
+}
+async function apiRequest(endpoint, options = {}) {
+  const apiKey = requireAuth();
+  const url = `${getBaseUrl()}${endpoint}`;
+  const response = await fetch(url, {
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${apiKey}`,
+      ...options.headers
+    }
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ message: "Unknown error" }));
+    if (response.status === 401) {
+      console.log(chalk.red("\n  Authentication failed. Run `riventa login` to re-authenticate.\n"));
+      process.exit(1);
+    }
+    throw new Error(error.error || error.message || `HTTP ${response.status}`);
+  }
+  return response.json();
+}
+
+// src/banner.ts
+import chalk2 from "chalk";
+function printBanner(version, email) {
+  console.log();
+  console.log(
+    chalk2.bold.white("RIVENTA") + chalk2.bold.hex("#2563EB")(".DEV")
+  );
+  console.log(
+    chalk2.gray(`Riventa CLI v${version}  \xB7  AI-powered DevOps`)
+  );
+  if (email) {
+    console.log(chalk2.gray(`Logged in as `) + chalk2.white(email));
+  }
+  console.log();
+}
+
+// src/commands/login.ts
+import chalk3 from "chalk";
+import inquirer from "inquirer";
+import ora from "ora";
+
+// src/utils/browser.ts
+import open from "open";
+import { exec } from "child_process";
+import { readFileSync, existsSync } from "fs";
+function openUrl(url) {
+  const isWSL = existsSync("/proc/version") && readFileSync("/proc/version", "utf-8").toLowerCase().includes("microsoft");
+  if (isWSL) {
+    return new Promise((resolve, reject) => {
+      exec(`cmd.exe /c start "" "${url.replace(/&/g, "^&")}"`, (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  }
+  return open(url).then(() => {
+  });
+}
+
+// src/commands/login.ts
+async function loginCommand() {
+  const existingKey = getApiKey();
+  if (existingKey) {
+    const user = getConfig("user");
+    if (user?.email) {
+      console.log(chalk3.gray(`
+  Already logged in as ${chalk3.white(user.email)}`));
+      const { reauth } = await inquirer.prompt([
+        {
+          type: "confirm",
+          name: "reauth",
+          message: "Do you want to re-authenticate?",
+          default: false
+        }
+      ]);
+      if (!reauth) return;
+    }
+  }
+  console.log();
+  console.log(chalk3.bold("  Welcome to Riventa.Dev CLI"));
+  console.log(chalk3.gray("  Connect your terminal to your Riventa account.\n"));
+  const { method } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "method",
+      message: "How would you like to authenticate?",
+      choices: [
+        {
+          name: `${chalk3.cyan("Browser")} \u2014 sign in via browser (recommended)`,
+          value: "browser"
+        },
+        {
+          name: `${chalk3.cyan("API Key")} \u2014 paste an existing API key`,
+          value: "manual"
+        }
+      ]
+    }
+  ]);
+  if (method === "browser") {
+    await deviceFlowLogin();
+  } else {
+    await manualLogin();
+  }
+}
+async function deviceFlowLogin() {
+  const baseUrl = getBaseUrl();
+  const spinner = ora("Requesting authorization...").start();
+  try {
+    const response = await fetch(`${baseUrl}/v1/auth/device`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response.ok) {
+      throw new Error("Failed to create device code");
+    }
+    const result = await response.json();
+    const { deviceCode, userCode, verificationUrl } = result.data;
+    spinner.stop();
+    console.log();
+    console.log(chalk3.bold("  Your device code:"));
+    console.log();
+    console.log(chalk3.cyan(`    ${userCode.slice(0, 4)} - ${userCode.slice(4)}`));
+    console.log();
+    console.log(chalk3.gray(`  Opening ${verificationUrl}`));
+    console.log(chalk3.gray("  Enter the code above to authorize this device.\n"));
+    try {
+      await openUrl(verificationUrl);
+    } catch {
+      console.log(chalk3.yellow(`  Could not open browser automatically.`));
+      console.log(chalk3.yellow(`  Please visit: ${chalk3.white(verificationUrl)}
+`));
+    }
+    const pollSpinner = ora("Waiting for authorization...").start();
+    const maxAttempts = 60;
+    let attempts = 0;
+    while (attempts < maxAttempts) {
+      await sleep(3e3);
+      attempts++;
+      try {
+        const pollResponse = await fetch(`${baseUrl}/v1/auth/device?code=${deviceCode}`);
+        const pollResult = await pollResponse.json();
+        if (pollResult.data?.status === "authorized") {
+          pollSpinner.succeed(chalk3.green("Authorized!"));
+          const { apiKey, user } = pollResult.data;
+          setConfig("apiKey", apiKey);
+          setConfig("user", user);
+          console.log();
+          console.log(chalk3.gray("  Logged in as: ") + chalk3.white(user.email));
+          if (user.name) console.log(chalk3.gray("  Name:         ") + chalk3.white(user.name));
+          console.log();
+          console.log(chalk3.gray("  Get started:"));
+          console.log(chalk3.gray("    riventa init      \u2014 initialize a project"));
+          console.log(chalk3.gray("    riventa projects  \u2014 list your projects"));
+          console.log(chalk3.gray("    riventa review    \u2014 run AI code review"));
+          console.log(chalk3.gray("    riventa --help    \u2014 see all commands"));
+          console.log();
+          return;
+        }
+        if (pollResult.data?.status !== "pending") {
+          pollSpinner.fail(chalk3.red("Authorization failed"));
+          console.log(chalk3.red("\n  The code may have expired. Run `riventa login` to try again.\n"));
+          process.exit(1);
+        }
+      } catch {
+      }
+    }
+    pollSpinner.fail(chalk3.red("Authorization timed out"));
+    console.log(chalk3.red("\n  The code expired. Run `riventa login` to try again.\n"));
+    process.exit(1);
+  } catch {
+    spinner.fail(chalk3.red("Failed to start authorization"));
+    console.log(chalk3.red("\n  Could not reach Riventa servers. Check your connection.\n"));
+    process.exit(1);
+  }
+}
+async function manualLogin() {
+  const answer = await inquirer.prompt([
+    {
+      type: "password",
+      name: "apiKey",
+      message: "Enter your API key (starts with riv_):",
+      mask: "*",
+      validate: (input) => {
+        if (!input.startsWith("riv_")) return 'API key must start with "riv_"';
+        if (input.length < 20) return "API key is too short";
+        return true;
+      }
+    }
+  ]);
+  await verifyAndSaveKey(answer.apiKey);
+}
+async function verifyAndSaveKey(apiKey) {
+  const spinner = ora("Verifying API key...").start();
+  try {
+    const baseUrl = getBaseUrl();
+    const response = await fetch(`${baseUrl}/v1/auth/verify`, {
+      headers: {
+        "Authorization": `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      throw new Error("Invalid API key");
+    }
+    const result = await response.json();
+    const data = result.data || result;
+    setConfig("apiKey", apiKey);
+    setConfig("user", data.user || data);
+    spinner.succeed(chalk3.green("Authenticated successfully!"));
+    const email = data.user?.email || data.email;
+    const name = data.user?.name || data.name;
+    console.log();
+    console.log(chalk3.gray("  Logged in as: ") + chalk3.white(email || "unknown"));
+    if (name) console.log(chalk3.gray("  Name:         ") + chalk3.white(name));
+    console.log();
+    console.log(chalk3.gray("  Get started:"));
+    console.log(chalk3.gray("    riventa init      \u2014 initialize a project"));
+    console.log(chalk3.gray("    riventa projects  \u2014 list your projects"));
+    console.log(chalk3.gray("    riventa review    \u2014 run AI code review"));
+    console.log(chalk3.gray("    riventa --help    \u2014 see all commands"));
+    console.log();
+  } catch {
+    spinner.fail(chalk3.red("Authentication failed"));
+    console.log(chalk3.red("\n  Invalid or expired API key. Please try again.\n"));
+    process.exit(1);
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/commands/init.ts
+import chalk4 from "chalk";
+import inquirer2 from "inquirer";
+import fs from "fs";
+import path from "path";
+import Conf2 from "conf";
+import ora2 from "ora";
+var config2 = new Conf2({ projectName: "riventa-cli" });
+function analyzeLocalProject() {
+  const analysis = {
+    name: path.basename(process.cwd())
+  };
+  const pkgPath = path.join(process.cwd(), "package.json");
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+      const allDeps = {
+        ...pkg.dependencies,
+        ...pkg.devDependencies
+      };
+      const depNames = Object.keys(allDeps);
+      analysis.dependencies = depNames;
+      analysis.scripts = pkg.scripts || {};
+      if (depNames.includes("next")) analysis.framework = "nextjs";
+      else if (depNames.includes("nuxt")) analysis.framework = "nuxt";
+      else if (depNames.includes("vue")) analysis.framework = "vue";
+      else if (depNames.includes("react")) analysis.framework = "react";
+      else if (depNames.includes("@angular/core")) analysis.framework = "angular";
+      else if (depNames.includes("svelte")) analysis.framework = "svelte";
+      else if (depNames.includes("express") || depNames.includes("fastify") || depNames.includes("koa")) {
+        analysis.framework = "nodejs";
+      }
+    } catch {
+    }
+  }
+  if (fs.existsSync(path.join(process.cwd(), "requirements.txt")) || fs.existsSync(path.join(process.cwd(), "pyproject.toml"))) {
+    analysis.framework = analysis.framework || "python";
+  }
+  if (fs.existsSync(path.join(process.cwd(), "go.mod"))) {
+    analysis.framework = analysis.framework || "go";
+  }
+  analysis.hasDockerfile = fs.existsSync(path.join(process.cwd(), "Dockerfile"));
+  analysis.hasTsConfig = fs.existsSync(path.join(process.cwd(), "tsconfig.json"));
+  analysis.hasGithubActions = fs.existsSync(path.join(process.cwd(), ".github"));
+  return analysis;
+}
+function getStaticTemplate(projectId, environment, autoReview, autoRollback) {
+  return `# Riventa.Dev Configuration
+# Generated by riventa init
+
+version: 1
+
+project:
+  id: ${projectId}
+
+# Code review settings
+review:
+  enabled: ${autoReview}
+  auto_comment: true
+  severity_threshold: warning
+  ignore_patterns:
+    - "*.test.js"
+    - "*.spec.ts"
+    - "dist/**"
+
+# Deployment settings
+deploy:
+  environment: ${environment}
+  auto_rollback: ${autoRollback}
+  health_check_url: /api/health
+  rollback_threshold: 5  # Error rate percentage
+
+# Notifications
+notifications:
+  slack:
+    enabled: false
+    channel: "#deployments"
+  email:
+    enabled: false
+`;
+}
+async function initCommand() {
+  console.log(chalk4.cyan("\n\u{1F680} Initialize Riventa.Dev\n"));
+  if (fs.existsSync(".riventa.yml")) {
+    const { overwrite } = await inquirer2.prompt([
+      {
+        type: "confirm",
+        name: "overwrite",
+        message: ".riventa.yml already exists. Overwrite?",
+        default: false
+      }
+    ]);
+    if (!overwrite) {
+      console.log(chalk4.yellow("\n  Initialization cancelled.\n"));
+      return;
+    }
+  }
+  const analysisSpinner = ora2("Analyzing project...").start();
+  const projectAnalysis = analyzeLocalProject();
+  analysisSpinner.succeed(`Detected: ${projectAnalysis.framework || "generic"} project`);
+  if (projectAnalysis.framework) {
+    console.log(chalk4.gray(`  Framework: ${projectAnalysis.framework}`));
+  }
+  if (projectAnalysis.hasTsConfig) {
+    console.log(chalk4.gray("  TypeScript: yes"));
+  }
+  if (projectAnalysis.hasDockerfile) {
+    console.log(chalk4.gray("  Docker: yes"));
+  }
+  console.log("");
+  const spinner = ora2("Fetching your projects...").start();
+  try {
+    const { projects } = await apiRequest("/v1/projects");
+    spinner.stop();
+    let projectId;
+    if (projects.length > 0) {
+      const { choice } = await inquirer2.prompt([
+        {
+          type: "list",
+          name: "choice",
+          message: "Select a project or create new:",
+          choices: [
+            ...projects.map((p) => ({ name: p.name, value: p.id })),
+            { name: "+ Create new project", value: "new" }
+          ]
+        }
+      ]);
+      if (choice === "new") {
+        projectId = await createNewProject();
+      } else {
+        projectId = choice;
+      }
+    } else {
+      projectId = await createNewProject();
+    }
+    const aiSpinner = ora2("Riv AI generating configuration...").start();
+    let configContent = null;
+    try {
+      const baseUrl = getBaseUrl();
+      const response = await apiRequest("/v1/projects/init-config", {
+        method: "POST",
+        body: JSON.stringify({
+          mode: "create",
+          projectAnalysis,
+          preferences: {
+            includeTests: true,
+            includeLinting: true,
+            includeDocker: projectAnalysis.hasDockerfile
+          }
+        })
+      });
+      if (response.success && response.data?.config) {
+        configContent = response.data.config;
+        aiSpinner.succeed("Riv AI generated configuration");
+        console.log(chalk4.cyan("\n  --- Generated Config Preview ---"));
+        const previewLines = configContent.split("\n").slice(0, 20);
+        previewLines.forEach((line) => {
+          console.log(chalk4.gray(`  ${line}`));
+        });
+        if (configContent.split("\n").length > 20) {
+          console.log(chalk4.gray("  ..."));
+        }
+        console.log(chalk4.cyan("  --- End Preview ---\n"));
+        if (response.data.explanation) {
+          console.log(chalk4.gray(`  ${response.data.explanation}
+`));
+        }
+        const { confirm } = await inquirer2.prompt([
+          {
+            type: "confirm",
+            name: "confirm",
+            message: "Apply this configuration?",
+            default: true
+          }
+        ]);
+        if (!confirm) {
+          configContent = null;
+        }
+      } else {
+        aiSpinner.warn("AI generation unavailable, using default template");
+        configContent = null;
+      }
+    } catch {
+      aiSpinner.warn("AI generation unavailable, using default template");
+      configContent = null;
+    }
+    if (!configContent) {
+      const answers = await inquirer2.prompt([
+        {
+          type: "list",
+          name: "environment",
+          message: "Default deployment environment:",
+          choices: ["production", "staging", "development"],
+          default: "production"
+        },
+        {
+          type: "confirm",
+          name: "autoReview",
+          message: "Enable automatic code review on commits?",
+          default: true
+        },
+        {
+          type: "confirm",
+          name: "autoRollback",
+          message: "Enable automatic rollback on failures?",
+          default: true
+        }
+      ]);
+      configContent = getStaticTemplate(projectId, answers.environment, answers.autoReview, answers.autoRollback);
+      console.log(chalk4.yellow("\n  Tip: Run `riventa config update` to enhance your config with AI.\n"));
+    }
+    fs.writeFileSync(".riventa.yml", configContent);
+    config2.set("projectId", projectId);
+    console.log(chalk4.green("\n\u2713 Riventa initialized successfully!"));
+    console.log(chalk4.gray("\n  Created .riventa.yml configuration file."));
+    console.log(chalk4.gray("  Run `riventa deploy` to deploy your project.\n"));
+  } catch (error) {
+    spinner.fail(chalk4.red("Failed to initialize"));
+    console.error(error);
+    process.exit(1);
+  }
+}
+async function createNewProject() {
+  const { name, repoUrl } = await inquirer2.prompt([
+    {
+      type: "input",
+      name: "name",
+      message: "Project name:",
+      default: path.basename(process.cwd())
+    },
+    {
+      type: "input",
+      name: "repoUrl",
+      message: "Repository URL (optional):"
+    }
+  ]);
+  const spinner = ora2("Creating project...").start();
+  const { project } = await apiRequest("/v1/projects", {
+    method: "POST",
+    body: JSON.stringify({ name, repoUrl })
+  });
+  spinner.succeed(`Created project: ${project.name}`);
+  return project.id;
+}
+
+// src/commands/deploy.ts
+import chalk5 from "chalk";
+import ora3 from "ora";
+async function deployCommand(options) {
+  const projectId = getProjectId();
+  if (!projectId) {
+    console.log(chalk5.red("\n\u2717 No project configured. Run `riventa init` first.\n"));
+    process.exit(1);
+  }
+  console.log(chalk5.cyan(`
+\u{1F680} Deploying to ${options.environment}...
+`));
+  const spinner = ora3("Creating deployment...").start();
+  try {
+    const { deployment } = await apiRequest("/v1/deployments", {
+      method: "POST",
+      body: JSON.stringify({
+        projectId,
+        environment: options.environment,
+        branch: options.branch || "main"
+      })
+    });
+    spinner.succeed(`Deployment created: ${deployment.id}`);
+    console.log(chalk5.gray(`
+  Status: ${deployment.status}`));
+    console.log(chalk5.gray(`  Environment: ${deployment.environment}`));
+    console.log(chalk5.gray(`  Branch: ${deployment.branch}`));
+    if (deployment.url) {
+      console.log(chalk5.green(`
+  URL: ${deployment.url}
+`));
+    }
+    console.log(chalk5.gray("  Run `riventa status` to check deployment progress.\n"));
+  } catch (error) {
+    spinner.fail(chalk5.red("Deployment failed"));
+    console.log(chalk5.red(`
+  ${error.message}
+`));
+    process.exit(1);
+  }
+}
+
+// src/commands/review.ts
+import chalk6 from "chalk";
+import ora4 from "ora";
+import fs2 from "fs";
+import { execSync } from "child_process";
+async function reviewCommand(options) {
+  const projectId = getProjectId();
+  if (!projectId) {
+    console.log(chalk6.red("\n\u2717 No project configured. Run `riventa init` first.\n"));
+    process.exit(1);
+  }
+  console.log(chalk6.cyan("\n\u{1F50D} Running AI Code Review...\n"));
+  let code;
+  let context;
+  if (options.file) {
+    if (!fs2.existsSync(options.file)) {
+      console.log(chalk6.red(`
+\u2717 File not found: ${options.file}
+`));
+      process.exit(1);
+    }
+    code = fs2.readFileSync(options.file, "utf-8");
+    context = `File: ${options.file}`;
+  } else if (options.pr) {
+    const spinner2 = ora4("Fetching PR diff...").start();
+    try {
+      const { diff } = await apiRequest(`/v1/projects/${projectId}/prs/${options.pr}/diff`);
+      code = diff;
+      context = `PR #${options.pr}`;
+      spinner2.stop();
+    } catch (error) {
+      spinner2.fail("Failed to fetch PR");
+      process.exit(1);
+    }
+  } else {
+    console.log(chalk6.yellow("  No file or PR specified. Reviewing staged changes...\n"));
+    try {
+      code = execSync("git diff --staged", { encoding: "utf-8" });
+      if (!code) {
+        code = execSync("git diff HEAD~1", { encoding: "utf-8" });
+      }
+      context = "Staged changes";
+    } catch {
+      console.log(chalk6.red("\n\u2717 No changes to review. Stage some files or specify --file or --pr.\n"));
+      process.exit(1);
+    }
+  }
+  const spinner = ora4("Analyzing code with AI...").start();
+  try {
+    const { review } = await apiRequest("/v1/reviews", {
+      method: "POST",
+      body: JSON.stringify({
+        projectId,
+        code,
+        context
+      })
+    });
+    spinner.succeed("Review complete!\n");
+    console.log(chalk6.bold(`  Score: ${getScoreEmoji(review.score)} ${review.score}/100
+`));
+    console.log(chalk6.bold("  Summary:"));
+    console.log(chalk6.gray(`  ${review.summary}
+`));
+    if (review.issues?.length > 0) {
+      console.log(chalk6.bold(`  Issues (${review.issues.length}):`));
+      review.issues.forEach((issue) => {
+        const icon = issue.severity === "error" ? "\u{1F534}" : issue.severity === "warning" ? "\u{1F7E1}" : "\u{1F535}";
+        console.log(chalk6.gray(`  ${icon} ${issue.message}`));
+        if (issue.line) {
+          console.log(chalk6.gray(`     Line ${issue.line}`));
+        }
+      });
+      console.log("");
+    }
+    if (review.suggestions?.length > 0) {
+      console.log(chalk6.bold("  Suggestions:"));
+      review.suggestions.forEach((suggestion, i) => {
+        console.log(chalk6.gray(`  ${i + 1}. ${suggestion}`));
+      });
+      console.log("");
+    }
+  } catch (error) {
+    spinner.fail(chalk6.red("Review failed"));
+    console.log(chalk6.red(`
+  ${error.message}
+`));
+    process.exit(1);
+  }
+}
+function getScoreEmoji(score) {
+  if (score >= 90) return "\u{1F7E2}";
+  if (score >= 70) return "\u{1F7E1}";
+  if (score >= 50) return "\u{1F7E0}";
+  return "\u{1F534}";
+}
+
+// src/commands/status.ts
+import chalk7 from "chalk";
+import ora5 from "ora";
+async function statusCommand() {
+  const projectId = getProjectId();
+  if (!projectId) {
+    console.log(chalk7.red("\n\u2717 No project configured. Run `riventa init` first.\n"));
+    process.exit(1);
+  }
+  console.log(chalk7.cyan("\n\u{1F4CA} Project Status\n"));
+  const spinner = ora5("Fetching status...").start();
+  try {
+    const [projectData, deploymentsData] = await Promise.all([
+      apiRequest(`/v1/projects/${projectId}`),
+      apiRequest(`/v1/projects/${projectId}/deployments?limit=5`)
+    ]);
+    spinner.stop();
+    const { project } = projectData;
+    const { deployments } = deploymentsData;
+    console.log(chalk7.bold("  Project:"));
+    console.log(chalk7.gray(`    Name: ${project.name}`));
+    console.log(chalk7.gray(`    ID: ${project.id}`));
+    if (project.repoUrl) {
+      console.log(chalk7.gray(`    Repository: ${project.repoUrl}`));
+    }
+    console.log("");
+    console.log(chalk7.bold("  Recent Deployments:"));
+    if (deployments.length === 0) {
+      console.log(chalk7.gray("    No deployments yet."));
+    } else {
+      deployments.forEach((d) => {
+        const statusIcon = getStatusIcon(d.status);
+        const date = new Date(d.createdAt).toLocaleString();
+        console.log(chalk7.gray(`    ${statusIcon} ${d.environment} - ${d.branch} (${date})`));
+        if (d.url) {
+          console.log(chalk7.gray(`       URL: ${d.url}`));
+        }
+      });
+    }
+    console.log("");
+    const activeDeployment = deployments.find((d) => d.status === "active");
+    if (activeDeployment) {
+      console.log(chalk7.bold("  Active Deployment:"));
+      console.log(chalk7.green(`    ${activeDeployment.environment} - ${activeDeployment.branch}`));
+      if (activeDeployment.url) {
+        console.log(chalk7.green(`    URL: ${activeDeployment.url}`));
+      }
+      console.log("");
+    }
+  } catch (error) {
+    spinner.fail(chalk7.red("Failed to fetch status"));
+    console.log(chalk7.red(`
+  ${error.message}
+`));
+    process.exit(1);
+  }
+}
+function getStatusIcon(status) {
+  switch (status) {
+    case "active":
+    case "success":
+      return "\u{1F7E2}";
+    case "building":
+    case "deploying":
+      return "\u{1F7E1}";
+    case "failed":
+    case "error":
+      return "\u{1F534}";
+    case "cancelled":
+      return "\u26AA";
+    default:
+      return "\u{1F535}";
+  }
+}
+
+// src/commands/logs.ts
+import chalk8 from "chalk";
+import ora6 from "ora";
+async function logsCommand(options) {
+  const projectId = getProjectId();
+  if (!projectId) {
+    console.log(chalk8.red("\n\u2717 No project configured. Run `riventa init` first.\n"));
+    process.exit(1);
+  }
+  console.log(chalk8.cyan("\n\u{1F4DD} Deployment Logs\n"));
+  const spinner = ora6("Fetching logs...").start();
+  try {
+    let deploymentId = options.deployment;
+    if (!deploymentId) {
+      const { deployments } = await apiRequest(`/v1/projects/${projectId}/deployments?limit=1`);
+      if (deployments.length === 0) {
+        spinner.fail("No deployments found");
+        process.exit(1);
+      }
+      deploymentId = deployments[0].id;
+    }
+    const { logs, deployment } = await apiRequest(`/v1/deployments/${deploymentId}/logs`);
+    spinner.stop();
+    console.log(chalk8.bold(`  Deployment: ${deployment.id}`));
+    console.log(chalk8.gray(`  Environment: ${deployment.environment}`));
+    console.log(chalk8.gray(`  Status: ${deployment.status}`));
+    console.log(chalk8.gray(`  Created: ${new Date(deployment.createdAt).toLocaleString()}`));
+    console.log("");
+    console.log(chalk8.bold("  Logs:"));
+    console.log(chalk8.gray("  " + "-".repeat(60)));
+    if (logs.length === 0) {
+      console.log(chalk8.gray("  No logs available yet."));
+    } else {
+      logs.forEach((log) => {
+        const timestamp = new Date(log.timestamp).toLocaleTimeString();
+        const levelColor = log.level === "error" ? chalk8.red : log.level === "warn" ? chalk8.yellow : chalk8.gray;
+        console.log(`  ${chalk8.dim(timestamp)} ${levelColor(`[${log.level.toUpperCase()}]`)} ${log.message}`);
+      });
+    }
+    console.log(chalk8.gray("  " + "-".repeat(60)));
+    console.log("");
+    if (options.follow && ["building", "deploying"].includes(deployment.status) && deploymentId) {
+      console.log(chalk8.yellow("  Following logs... (Ctrl+C to exit)\n"));
+      await followLogs(deploymentId);
+    }
+  } catch (error) {
+    spinner.fail(chalk8.red("Failed to fetch logs"));
+    console.log(chalk8.red(`
+  ${error.message}
+`));
+    process.exit(1);
+  }
+}
+async function followLogs(deploymentId) {
+  let lastLogId = null;
+  const poll = async () => {
+    try {
+      const params = lastLogId ? `?after=${lastLogId}` : "";
+      const { logs, deployment } = await apiRequest(`/v1/deployments/${deploymentId}/logs${params}`);
+      if (logs.length > 0) {
+        logs.forEach((log) => {
+          const timestamp = new Date(log.timestamp).toLocaleTimeString();
+          const levelColor = log.level === "error" ? chalk8.red : log.level === "warn" ? chalk8.yellow : chalk8.gray;
+          console.log(`  ${chalk8.dim(timestamp)} ${levelColor(`[${log.level.toUpperCase()}]`)} ${log.message}`);
+        });
+        lastLogId = logs[logs.length - 1].id;
+      }
+      if (["building", "deploying"].includes(deployment.status)) {
+        setTimeout(poll, 2e3);
+      } else {
+        console.log("");
+        console.log(chalk8.bold(`  Deployment ${deployment.status === "active" ? "succeeded" : "failed"}!`));
+        if (deployment.url) {
+          console.log(chalk8.green(`  URL: ${deployment.url}`));
+        }
+        console.log("");
+      }
+    } catch (error) {
+      console.log(chalk8.red("  Error polling logs. Retrying..."));
+      setTimeout(poll, 5e3);
+    }
+  };
+  await poll();
+}
+
+// src/commands/rollback.ts
+import chalk9 from "chalk";
+import inquirer3 from "inquirer";
+import ora7 from "ora";
+async function rollbackCommand(options) {
+  const projectId = getProjectId();
+  if (!projectId) {
+    console.log(chalk9.red("\n\u2717 No project configured. Run `riventa init` first.\n"));
+    process.exit(1);
+  }
+  console.log(chalk9.cyan("\n\u23EA Rollback Deployment\n"));
+  let targetDeploymentId = options.deployment;
+  if (!targetDeploymentId) {
+    const spinner2 = ora7("Fetching deployments...").start();
+    try {
+      const { deployments } = await apiRequest(`/v1/projects/${projectId}/deployments?limit=10`);
+      spinner2.stop();
+      if (deployments.length < 2) {
+        console.log(chalk9.yellow("  No previous deployments to rollback to.\n"));
+        return;
+      }
+      const successfulDeployments = deployments.filter(
+        (d) => d.status === "active" || d.status === "success"
+      );
+      if (successfulDeployments.length < 2) {
+        console.log(chalk9.yellow("  No previous successful deployments to rollback to.\n"));
+        return;
+      }
+      const previousDeployments = successfulDeployments.slice(1);
+      const { selected } = await inquirer3.prompt([
+        {
+          type: "list",
+          name: "selected",
+          message: "Select a deployment to rollback to:",
+          choices: previousDeployments.map((d) => ({
+            name: `${d.environment} - ${d.branch} (${new Date(d.createdAt).toLocaleDateString()})`,
+            value: d.id
+          }))
+        }
+      ]);
+      targetDeploymentId = selected;
+    } catch (error) {
+      spinner2.fail(chalk9.red("Failed to fetch deployments"));
+      console.log(chalk9.red(`
+  ${error.message}
+`));
+      process.exit(1);
+    }
+  }
+  const { confirmed } = await inquirer3.prompt([
+    {
+      type: "confirm",
+      name: "confirmed",
+      message: `Are you sure you want to rollback to deployment ${targetDeploymentId}?`,
+      default: false
+    }
+  ]);
+  if (!confirmed) {
+    console.log(chalk9.yellow("\n  Rollback cancelled.\n"));
+    return;
+  }
+  const spinner = ora7("Rolling back...").start();
+  try {
+    const { deployment } = await apiRequest(`/v1/deployments/${targetDeploymentId}/rollback`, {
+      method: "POST"
+    });
+    spinner.succeed(chalk9.green("Rollback initiated!"));
+    console.log(chalk9.gray(`
+  New deployment ID: ${deployment.id}`));
+    console.log(chalk9.gray(`  Status: ${deployment.status}`));
+    if (deployment.url) {
+      console.log(chalk9.green(`
+  URL: ${deployment.url}
+`));
+    }
+    console.log(chalk9.gray("  Run `riventa status` to check rollback progress.\n"));
+  } catch (error) {
+    spinner.fail(chalk9.red("Rollback failed"));
+    console.log(chalk9.red(`
+  ${error.message}
+`));
+    process.exit(1);
+  }
+}
+
+// src/commands/config.ts
+import chalk10 from "chalk";
+import inquirer4 from "inquirer";
+async function configCommand(options) {
+  console.log(chalk10.cyan("\n\u2699\uFE0F  CLI Configuration\n"));
+  if (options.get) {
+    const value = getConfig(options.get);
+    if (value !== void 0) {
+      console.log(chalk10.gray(`  ${options.get}: ${formatValue(value)}`));
+    } else {
+      console.log(chalk10.yellow(`  Config key '${options.get}' not found.`));
+    }
+    console.log("");
+    return;
+  }
+  if (options.set) {
+    const [key, ...valueParts] = options.set.split("=");
+    const value = valueParts.join("=");
+    if (!key || value === void 0) {
+      console.log(chalk10.red("  Invalid format. Use --set key=value"));
+      console.log("");
+      return;
+    }
+    let parsedValue = value;
+    if (value === "true") parsedValue = true;
+    else if (value === "false") parsedValue = false;
+    else if (!isNaN(Number(value)) && value !== "") parsedValue = Number(value);
+    setConfig(key, parsedValue);
+    console.log(chalk10.green(`  \u2713 Set ${key} = ${formatValue(parsedValue)}`));
+    console.log("");
+    return;
+  }
+  if (options.list) {
+    const config3 = getAllConfig();
+    const keys = Object.keys(config3);
+    if (keys.length === 0) {
+      console.log(chalk10.gray("  No configuration set."));
+    } else {
+      console.log(chalk10.bold("  Current Configuration:"));
+      console.log("");
+      keys.forEach((key) => {
+        const value = config3[key];
+        if (key === "apiKey") {
+          console.log(chalk10.gray(`  ${key}: ********`));
+        } else {
+          console.log(chalk10.gray(`  ${key}: ${formatValue(value)}`));
+        }
+      });
+    }
+    console.log("");
+    return;
+  }
+  console.log(chalk10.bold("  Usage:"));
+  console.log(chalk10.gray("    riventa config --list          List all configuration"));
+  console.log(chalk10.gray("    riventa config --get <key>     Get a specific config value"));
+  console.log(chalk10.gray("    riventa config --set <k=v>     Set a config value"));
+  console.log("");
+  console.log(chalk10.bold("  Available Keys:"));
+  console.log(chalk10.gray("    apiKey       Your Riventa API key"));
+  console.log(chalk10.gray("    baseUrl      API base URL (default: https://api.riventa.dev)"));
+  console.log(chalk10.gray("    projectId    Current project ID"));
+  console.log(chalk10.gray("    user         Authenticated user info"));
+  console.log(chalk10.gray("    organization Organization info"));
+  console.log("");
+}
+function formatValue(value) {
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+
+// src/commands/projects.ts
+import chalk11 from "chalk";
+import ora8 from "ora";
+import inquirer5 from "inquirer";
+async function projectsCommand() {
+  console.log(chalk11.cyan("\n\u{1F4C1} Your Projects\n"));
+  const spinner = ora8("Fetching projects...").start();
+  try {
+    const { projects } = await apiRequest("/v1/projects");
+    spinner.stop();
+    if (projects.length === 0) {
+      console.log(chalk11.gray("  No projects found."));
+      console.log(chalk11.gray("  Run `riventa init` to create a project.\n"));
+      return;
+    }
+    const currentProjectId = getProjectId();
+    console.log(chalk11.bold("  Projects:"));
+    console.log("");
+    projects.forEach((project) => {
+      const isActive = project.id === currentProjectId;
+      const marker = isActive ? chalk11.green("\u2713") : " ";
+      const name = isActive ? chalk11.green(project.name) : project.name;
+      console.log(`  ${marker} ${name}`);
+      console.log(chalk11.gray(`    ID: ${project.id}`));
+      if (project.repoUrl) {
+        console.log(chalk11.gray(`    Repo: ${project.repoUrl}`));
+      }
+      if (project.lastDeployment) {
+        const date = new Date(project.lastDeployment.createdAt).toLocaleDateString();
+        console.log(chalk11.gray(`    Last deploy: ${project.lastDeployment.environment} (${date})`));
+      }
+      console.log("");
+    });
+    const { switchProject } = await inquirer5.prompt([
+      {
+        type: "confirm",
+        name: "switchProject",
+        message: "Switch to a different project?",
+        default: false
+      }
+    ]);
+    if (switchProject) {
+      const { selectedProject } = await inquirer5.prompt([
+        {
+          type: "list",
+          name: "selectedProject",
+          message: "Select a project:",
+          choices: projects.map((p) => ({
+            name: `${p.name}${p.id === currentProjectId ? " (current)" : ""}`,
+            value: p.id
+          }))
+        }
+      ]);
+      setConfig("projectId", selectedProject);
+      const selectedName = projects.find((p) => p.id === selectedProject)?.name;
+      console.log(chalk11.green(`
+  \u2713 Switched to project: ${selectedName}
+`));
+    }
+  } catch (error) {
+    spinner.fail(chalk11.red("Failed to fetch projects"));
+    console.log(chalk11.red(`
+  ${error.message}
+`));
+    process.exit(1);
+  }
+}
+
+// src/commands/whoami.ts
+import chalk12 from "chalk";
+import ora9 from "ora";
+async function whoamiCommand() {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    console.log(chalk12.red("\n  Not authenticated. Run `riventa login` first.\n"));
+    process.exit(1);
+  }
+  const spinner = ora9("Fetching account info...").start();
+  try {
+    const result = await apiRequest("/v1/auth/verify");
+    const data = result.data || result;
+    const user = data.user || data;
+    spinner.stop();
+    console.log();
+    console.log(chalk12.bold("  Account"));
+    console.log(chalk12.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(chalk12.gray("  Email:   ") + chalk12.white(user.email || "unknown"));
+    if (user.name) console.log(chalk12.gray("  Name:    ") + chalk12.white(user.name));
+    if (user.plan) console.log(chalk12.gray("  Plan:    ") + chalk12.cyan(user.plan));
+    console.log(chalk12.gray("  API Key: ") + chalk12.white(apiKey.slice(0, 12) + "..."));
+    console.log();
+  } catch (error) {
+    spinner.fail(chalk12.red("Failed to fetch account info"));
+    console.log(chalk12.red(`  ${error.message}
+`));
+  }
+}
+
+// src/commands/security.ts
+import chalk13 from "chalk";
+import ora10 from "ora";
+async function securityCommand(options) {
+  const projectId = requireProject();
+  if (options.scan) {
+    await runScan(projectId);
+  } else if (options.score) {
+    await showScore(projectId);
+  } else {
+    await showScore(projectId);
+  }
+}
+async function runScan(projectId) {
+  const spinner = ora10("Running security scan...").start();
+  try {
+    const result = await apiRequest("/v1/security/scan", {
+      method: "POST",
+      body: JSON.stringify({
+        projectId,
+        scanType: "comprehensive"
+      })
+    });
+    const scan = result.data || result;
+    spinner.succeed("Security scan complete");
+    console.log();
+    if (scan.score !== void 0) {
+      const scoreColor = scan.score >= 80 ? chalk13.green : scan.score >= 60 ? chalk13.yellow : chalk13.red;
+      console.log(chalk13.gray("  Score: ") + scoreColor(scan.score + "/100"));
+    }
+    const vulns = scan.vulnerabilities || [];
+    if (vulns.length === 0) {
+      console.log(chalk13.green("\n  No vulnerabilities found!\n"));
+      return;
+    }
+    console.log(chalk13.gray(`
+  Found ${vulns.length} vulnerabilities:
+`));
+    const severityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+    const sorted = [...vulns].sort(
+      (a, b) => (severityOrder[a.severity] || 4) - (severityOrder[b.severity] || 4)
+    );
+    for (const vuln of sorted) {
+      const icon = getSeverityIcon(vuln.severity);
+      console.log(`  ${icon} ${chalk13.bold(vuln.title)}`);
+      if (vuln.description) console.log(chalk13.gray(`     ${vuln.description}`));
+      if (vuln.package) console.log(chalk13.gray(`     Package: ${vuln.package}`));
+      if (vuln.fixAvailable) console.log(chalk13.green("     Fix available"));
+      console.log();
+    }
+  } catch (error) {
+    spinner.fail(chalk13.red("Security scan failed"));
+    console.log(chalk13.red(`  ${error.message}
+`));
+  }
+}
+async function showScore(projectId) {
+  const spinner = ora10("Fetching security score...").start();
+  try {
+    const result = await apiRequest(`/v1/security/score?projectId=${projectId}`);
+    const score = result.data || result;
+    spinner.stop();
+    console.log();
+    const overall = score.overall ?? score.score ?? 0;
+    const color = overall >= 80 ? chalk13.green : overall >= 60 ? chalk13.yellow : chalk13.red;
+    console.log(chalk13.bold("  Security Score"));
+    console.log(chalk13.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(chalk13.gray("  Overall: ") + color(`${overall}/100`));
+    if (score.categories) {
+      console.log();
+      for (const [category, value] of Object.entries(score.categories)) {
+        const catColor = value >= 80 ? chalk13.green : value >= 60 ? chalk13.yellow : chalk13.red;
+        console.log(chalk13.gray(`  ${category}: `) + catColor(`${value}`));
+      }
+    }
+    console.log();
+  } catch (error) {
+    spinner.fail(chalk13.red("Failed to fetch security score"));
+    console.log(chalk13.red(`  ${error.message}
+`));
+  }
+}
+function getSeverityIcon(severity) {
+  switch (severity) {
+    case "critical":
+      return chalk13.red.bold("CRIT");
+    case "high":
+      return chalk13.red("HIGH");
+    case "medium":
+      return chalk13.yellow("MED ");
+    case "low":
+      return chalk13.gray("LOW ");
+    default:
+      return chalk13.gray("INFO");
+  }
+}
+
+// src/commands/health.ts
+import chalk14 from "chalk";
+import ora11 from "ora";
+async function healthCommand() {
+  const spinner = ora11("Checking API status...").start();
+  try {
+    const baseUrl = getBaseUrl();
+    const response = await fetch(`${baseUrl}/v1/health`);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const result = await response.json();
+    const data = result.data || result;
+    spinner.succeed(chalk14.green("API is operational"));
+    console.log();
+    console.log(chalk14.gray("  Status:      ") + chalk14.green(data.status || "operational"));
+    console.log(chalk14.gray("  Version:     ") + chalk14.white(data.version || "unknown"));
+    console.log(chalk14.gray("  Environment: ") + chalk14.white(data.environment || "unknown"));
+    console.log(chalk14.gray("  Endpoint:    ") + chalk14.white(baseUrl));
+    console.log();
+  } catch (error) {
+    spinner.fail(chalk14.red("API is unreachable"));
+    console.log(chalk14.red(`  ${error.message}`));
+    console.log(chalk14.gray(`  Endpoint: ${getBaseUrl()}
+`));
+  }
+}
+
+// src/commands/dashboard.ts
+import chalk15 from "chalk";
+var BASE = "https://app.riventa.dev";
+var pages = {
+  home: "/dashboard",
+  reviews: "/ci-cd?tab=reviews",
+  deployments: "/deployments",
+  analytics: "/analytics",
+  security: "/code-quality?tab=security",
+  settings: "/settings",
+  "api-keys": "/settings?tab=api-keys",
+  flags: "/flags",
+  monitoring: "/monitoring"
+};
+async function dashboardCommand(options) {
+  const page = options.page || "home";
+  const path2 = pages[page];
+  if (!path2) {
+    console.log(chalk15.red(`
+  Unknown page: ${page}`));
+    console.log(chalk15.gray("  Available pages: ") + chalk15.white(Object.keys(pages).join(", ")));
+    console.log();
+    return;
+  }
+  const url = `${BASE}${path2}`;
+  console.log(chalk15.gray(`
+  Opening ${url}
+`));
+  try {
+    await openUrl(url);
+  } catch {
+    console.log(chalk15.yellow(`  Could not open browser. Visit: ${chalk15.white(url)}
+`));
+  }
+}
+
+// src/repl.ts
+var VERSION = "1.2.0";
+var commands = {
+  login: { description: "Sign in via browser", action: loginCommand },
+  logout: { description: "Log out and clear credentials", action: async () => {
+    const Conf3 = (await import("conf")).default;
+    const config3 = new Conf3({ projectName: "riventa-cli" });
+    config3.clear();
+    console.log(chalk16.green("\n  Logged out successfully. Credentials cleared.\n"));
+  } },
+  whoami: { description: "Show current authenticated user", action: whoamiCommand },
+  init: { description: "Initialize Riventa in current directory", action: initCommand },
+  projects: { description: "List and switch between projects", action: projectsCommand },
+  deploy: { description: "Deploy current branch", action: deployCommand },
+  status: { description: "View project and deployment status", action: statusCommand },
+  logs: { description: "View deployment logs", action: logsCommand },
+  rollback: { description: "Rollback to a previous deployment", action: rollbackCommand },
+  review: { description: "Run AI code review on changes", action: reviewCommand },
+  security: { description: "Security scanning and score", action: securityCommand },
+  config: { description: "Manage CLI configuration", action: configCommand },
+  health: { description: "Check API connectivity and status", action: healthCommand },
+  dashboard: { description: "Open dashboard in browser", action: dashboardCommand },
+  open: { description: "Open dashboard in browser", action: () => dashboardCommand({}) }
+};
+function showHelp() {
+  console.log();
+  console.log(chalk16.bold("  Available commands:"));
+  console.log();
+  const maxLen = Math.max(...Object.keys(commands).map((k) => k.length));
+  for (const [name, cmd] of Object.entries(commands)) {
+    console.log(chalk16.cyan(`  ${name.padEnd(maxLen + 2)}`) + chalk16.gray(cmd.description));
+  }
+  console.log();
+  console.log(chalk16.gray("  help") + chalk16.gray("".padEnd(maxLen - 2)) + chalk16.gray("Show this help"));
+  console.log(chalk16.gray("  clear") + chalk16.gray("".padEnd(maxLen - 3)) + chalk16.gray("Clear the screen"));
+  console.log(chalk16.gray("  exit") + chalk16.gray("".padEnd(maxLen - 2)) + chalk16.gray("Exit the CLI"));
+  console.log();
+}
+async function startRepl() {
+  const user = getConfig("user");
+  printBanner(VERSION, user?.email);
+  const cwd = process.cwd().split("/").pop() || "~";
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: chalk16.hex("#2563EB")("riventa") + chalk16.gray(`:${cwd}`) + chalk16.white("> "),
+    completer: (line) => {
+      const completions = [...Object.keys(commands), "help", "clear", "exit"];
+      const hits = completions.filter((c) => c.startsWith(line.trim()));
+      return [hits.length ? hits : completions, line];
+    }
+  });
+  rl.prompt();
+  rl.on("line", async (line) => {
+    const input = line.trim();
+    const [cmd, ...args] = input.split(/\s+/);
+    if (!cmd) {
+      rl.prompt();
+      return;
+    }
+    if (cmd === "exit" || cmd === "quit") {
+      console.log(chalk16.gray("\n  Goodbye!\n"));
+      process.exit(0);
+    }
+    if (cmd === "help") {
+      showHelp();
+      rl.prompt();
+      return;
+    }
+    if (cmd === "clear") {
+      console.clear();
+      const u = getConfig("user");
+      printBanner(VERSION, u?.email);
+      rl.prompt();
+      return;
+    }
+    if (cmd === "version") {
+      console.log(chalk16.gray(`
+  v${VERSION}
+`));
+      rl.prompt();
+      return;
+    }
+    const command = commands[cmd];
+    if (!command) {
+      console.log(chalk16.red(`
+  Unknown command: ${cmd}`));
+      console.log(chalk16.gray("  Type ") + chalk16.cyan("help") + chalk16.gray(" to see available commands.\n"));
+      rl.prompt();
+      return;
+    }
+    try {
+      const originalExit = process.exit;
+      process.exit = (() => {
+        throw new Error("__REPL_EXIT__");
+      });
+      await command.action({ ...Object.fromEntries(args.map((a, i) => [i, a])) });
+      process.exit = originalExit;
+    } catch (err) {
+      if (err?.message !== "__REPL_EXIT__") {
+        console.log(chalk16.red(`
+  Error: ${err.message}
+`));
+      }
+      process.exit = (await import("process")).exit;
+    }
+    console.log();
+    rl.prompt();
+  });
+  rl.on("close", () => {
+    console.log(chalk16.gray("\n  Goodbye!\n"));
+    process.exit(0);
+  });
+}
+export {
+  startRepl
+};