vibora 4.7.2 → 4.8.0

package/README.md

@@ -29,11 +29,29 @@ The Vibe Engineer's Cockpit. Orchestrate Claude Code across parallel workstreams
 
 ## Quick Start
 
-Requires [Bun](https://bun.sh/) and [Claude Code](https://claude.ai/code).
+```bash
+npx vibora@latest up
+```
+
+That's it! Vibora will:
+- Check for required dependencies (bun, dtach, Claude Code, uv)
+- Offer to install any that are missing
+- Start the server on http://localhost:7777
+- Show getting started tips
+
+Open http://localhost:7777 in your browser.
 
-### Desktop App (Recommended)
+### Check Your Setup
 
-Download the latest release:
+```bash
+vibora doctor
+```
+
+Shows the status of all dependencies with versions.
+
+### Desktop App
+
+Download the desktop app for a bundled experience:
 
 | Platform | Download |
 |----------|----------|
@@ -43,47 +61,32 @@ Download the latest release:
 The desktop app bundles everything—just install and run. It will start the server, install the Claude Code plugin, and check for updates automatically.
 
 <details>
-<summary>👉 <strong>macOS Installation</strong></summary>
-
-1. Open the DMG and drag Vibora to Applications:
+<summary>macOS Installation Notes</summary>
 
-   ![DMG Installer](./screenshots/macos-dmg-installer.png)
-
-2. On first launch, macOS will block the app:
-
-   ![Gatekeeper Blocked](./screenshots/macos-gatekeeper-blocked.png)
-
-3. Open **System Settings → Privacy & Security**, scroll down, and click **Open Anyway**:
-
-   ![Privacy & Security](./screenshots/macos-privacy-security-open-anyway.png)
-
-4. Confirm by clicking **Open Anyway** in the dialog:
-
-   ![Open Anyway](./screenshots/macos-gatekeeper-open-anyway.png)
+1. Open the DMG and drag Vibora to Applications
+2. On first launch, macOS will block the app
+3. Open **System Settings → Privacy & Security**, scroll down, and click **Open Anyway**
+4. Confirm by clicking **Open Anyway** in the dialog
 
 </details>
 
-### Web Application
+### Install Script
 
-Run Vibora as a web server for browser access or remote deployment.
+For automated installation (useful for remote servers):
 
 ```bash
-# Install and start with curl
 curl -fsSL https://raw.githubusercontent.com/knowsuchagency/vibora/main/install.sh | bash
-
-# Or install via npm
-npx vibora@latest up
 ```
 
-If using npm, install the Claude Code plugin separately:
+### Claude Code Plugin
+
+Install the plugin for automatic status sync and task management:
 
 ```bash
 claude plugin marketplace add knowsuchagency/vibora
 claude plugin install vibora@vibora --scope user
 ```
 
-Open http://localhost:7777 in your browser.
-
 ## Features
 
 ### Kanban Board
@@ -244,8 +247,10 @@ The CLI lets AI agents working inside task worktrees query and update task statu
 
 ```bash
 vibora up                        # Start server daemon
+vibora up -y                     # Start with auto-install (no prompts)
 vibora down                      # Stop server
 vibora status                    # Check server status
+vibora doctor                    # Check all dependencies
 vibora health                    # Check server health
 vibora mcp                       # Start MCP server (stdio)
 ```

package/bin/vibora.js

@@ -29881,6 +29881,9 @@ var prettyOutput = false;
 function setPrettyOutput(value) {
   prettyOutput = value;
 }
+function isPrettyOutput() {
+  return prettyOutput;
+}
 function output(data) {
   const response = {
     success: true,
@@ -30157,45 +30160,183 @@ async function confirm(message) {
 // cli/src/commands/up.ts
 init_server();
 
-// cli/src/utils/install.ts
+// cli/src/utils/dependencies.ts
 import { execSync, spawnSync } from "child_process";
-function isBrewInstalled() {
-  try {
-    execSync("which brew", { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
+var DEPENDENCIES = [
+  {
+    name: "bun",
+    command: "bun",
+    description: "Runtime for Vibora server",
+    required: true,
+    install: {
+      brew: "brew install oven-sh/bun/bun",
+      curl: "curl -fsSL https://bun.sh/install | bash"
+    }
+  },
+  {
+    name: "dtach",
+    command: "dtach",
+    description: "Terminal session persistence",
+    required: true,
+    install: {
+      brew: "brew install dtach",
+      apt: "sudo apt install -y dtach",
+      dnf: "sudo dnf install -y dtach",
+      pacman: "sudo pacman -S --noconfirm dtach"
+    }
+  },
+  {
+    name: "claude",
+    command: "claude",
+    description: "Claude Code CLI for AI agents",
+    required: true,
+    install: {
+      npm: "npm install -g @anthropic-ai/claude-code"
+    }
+  },
+  {
+    name: "uv",
+    command: "uv",
+    description: "Fast Python package manager",
+    required: true,
+    install: {
+      brew: "brew install uv",
+      curl: "curl -LsSf https://astral.sh/uv/install.sh | sh"
+    }
+  },
+  {
+    name: "gh",
+    command: "gh",
+    description: "GitHub CLI for PR creation",
+    required: false,
+    install: {
+      brew: "brew install gh",
+      apt: "sudo apt install -y gh",
+      dnf: "sudo dnf install -y gh",
+      pacman: "sudo pacman -S --noconfirm github-cli"
+    }
+  }
+];
+function detectPackageManager() {
+  const managers = ["brew", "apt", "dnf", "pacman"];
+  for (const pm of managers) {
+    try {
+      execSync(`which ${pm}`, { stdio: "ignore" });
+      return pm;
+    } catch {}
   }
+  return null;
 }
-function isBunInstalled() {
+function isCommandInstalled(command) {
   try {
-    execSync("which bun", { stdio: "ignore" });
+    execSync(`which ${command}`, { stdio: "ignore" });
     return true;
   } catch {
     return false;
   }
 }
-function isDtachInstalled() {
+function getCommandVersion(command) {
   try {
-    execSync("which dtach", { stdio: "ignore" });
-    return true;
+    const output2 = execSync(`${command} --version`, { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] });
+    return output2.trim().split(`
+`)[0];
   } catch {
-    return false;
+    return null;
   }
 }
-function installDtach() {
-  const hasBrew = isBrewInstalled();
-  const cmd = hasBrew ? "brew install dtach" : "sudo apt install -y dtach";
+function checkDependency(dep) {
+  const installed = isCommandInstalled(dep.command);
+  return {
+    name: dep.name,
+    command: dep.command,
+    description: dep.description,
+    required: dep.required,
+    installed,
+    version: installed ? getCommandVersion(dep.command) : null
+  };
+}
+function checkAllDependencies() {
+  return DEPENDENCIES.map(checkDependency);
+}
+function getInstallCommand(dep) {
+  const pm = detectPackageManager();
+  if (pm && dep.install[pm]) {
+    return dep.install[pm];
+  }
+  if (dep.install.npm) {
+    return dep.install.npm;
+  }
+  if (dep.install.curl) {
+    return dep.install.curl;
+  }
+  const available = Object.values(dep.install).filter(Boolean);
+  return available[0] || `Please install ${dep.name} manually`;
+}
+function getInstallMethod(dep) {
+  const pm = detectPackageManager();
+  if (pm && dep.install[pm]) {
+    const methodNames = {
+      brew: "Homebrew",
+      apt: "apt",
+      dnf: "dnf",
+      pacman: "pacman"
+    };
+    return methodNames[pm] || pm;
+  }
+  if (dep.install.npm) {
+    return "npm";
+  }
+  if (dep.install.curl) {
+    return "curl script";
+  }
+  return "manual installation";
+}
+function installDependency(dep) {
+  const cmd = getInstallCommand(dep);
   console.error(`Running: ${cmd}`);
   const result = spawnSync(cmd, { shell: true, stdio: "inherit" });
   return result.status === 0;
 }
+function getDependency(name) {
+  return DEPENDENCIES.find((d) => d.name === name);
+}
+
+// cli/src/utils/install.ts
+function isBunInstalled() {
+  return isCommandInstalled("bun");
+}
+function isDtachInstalled() {
+  return isCommandInstalled("dtach");
+}
+function isClaudeInstalled() {
+  return isCommandInstalled("claude");
+}
+function isUvInstalled() {
+  return isCommandInstalled("uv");
+}
+function installDtach() {
+  const dep = getDependency("dtach");
+  if (!dep)
+    return false;
+  return installDependency(dep);
+}
 function installBun() {
-  const hasBrew = isBrewInstalled();
-  const cmd = hasBrew ? "brew install oven-sh/bun/bun" : "curl -fsSL https://bun.sh/install | bash";
-  console.error(`Running: ${cmd}`);
-  const result = spawnSync(cmd, { shell: true, stdio: "inherit" });
-  return result.status === 0;
+  const dep = getDependency("bun");
+  if (!dep)
+    return false;
+  return installDependency(dep);
+}
+function installClaude() {
+  const dep = getDependency("claude");
+  if (!dep)
+    return false;
+  return installDependency(dep);
+}
+function installUv() {
+  const dep = getDependency("uv");
+  if (!dep)
+    return false;
+  return installDependency(dep);
 }
 
 // cli/src/commands/up.ts
@@ -30211,11 +30352,13 @@ function getPackageRoot() {
   return dirname2(dirname2(dirname2(currentFile)));
 }
 async function handleUpCommand(flags) {
+  const autoYes = flags.yes === "true" || flags.y === "true";
   if (!isBunInstalled()) {
-    const hasBrew = isBrewInstalled();
-    const method = hasBrew ? "Homebrew" : "curl script";
+    const bunDep = getDependency("bun");
+    const method = getInstallMethod(bunDep);
     console.error("Bun is required to run Vibora but is not installed.");
-    const shouldInstall = await confirm(`Would you like to install bun via ${method}?`);
+    console.error("  Bun is the JavaScript runtime that powers Vibora.");
+    const shouldInstall = autoYes || await confirm(`Would you like to install bun via ${method}?`);
     if (shouldInstall) {
       const success = installBun();
       if (!success) {
@@ -30223,14 +30366,15 @@ async function handleUpCommand(flags) {
       }
       console.error("Bun installed successfully!");
     } else {
-      throw new CliError("MISSING_DEPENDENCY", "Bun is required. Install manually: brew install oven-sh/bun/bun (macOS) or curl -fsSL https://bun.sh/install | bash", ExitCodes.ERROR);
+      throw new CliError("MISSING_DEPENDENCY", `Bun is required. Install manually: ${getInstallCommand(bunDep)}`, ExitCodes.ERROR);
     }
   }
   if (!isDtachInstalled()) {
-    const hasBrew = isBrewInstalled();
-    const method = hasBrew ? "Homebrew" : "apt";
+    const dtachDep = getDependency("dtach");
+    const method = getInstallMethod(dtachDep);
     console.error("dtach is required for terminal persistence but is not installed.");
-    const shouldInstall = await confirm(`Would you like to install dtach via ${method}?`);
+    console.error("  dtach enables persistent terminal sessions that survive disconnects.");
+    const shouldInstall = autoYes || await confirm(`Would you like to install dtach via ${method}?`);
     if (shouldInstall) {
       const success = installDtach();
       if (!success) {
@@ -30238,13 +30382,45 @@ async function handleUpCommand(flags) {
       }
       console.error("dtach installed successfully!");
     } else {
-      throw new CliError("MISSING_DEPENDENCY", "dtach is required. Install manually: brew install dtach (macOS) or apt install dtach (Linux)", ExitCodes.ERROR);
+      throw new CliError("MISSING_DEPENDENCY", `dtach is required. Install manually: ${getInstallCommand(dtachDep)}`, ExitCodes.ERROR);
+    }
+  }
+  if (!isClaudeInstalled()) {
+    const claudeDep = getDependency("claude");
+    const method = getInstallMethod(claudeDep);
+    console.error("Claude Code CLI is required but is not installed.");
+    console.error("  Claude Code is the AI coding agent that Vibora orchestrates.");
+    const shouldInstall = autoYes || await confirm(`Would you like to install Claude Code via ${method}?`);
+    if (shouldInstall) {
+      const success = installClaude();
+      if (!success) {
+        throw new CliError("INSTALL_FAILED", "Failed to install Claude Code", ExitCodes.ERROR);
+      }
+      console.error("Claude Code installed successfully!");
+    } else {
+      throw new CliError("MISSING_DEPENDENCY", `Claude Code is required. Install manually: ${getInstallCommand(claudeDep)}`, ExitCodes.ERROR);
+    }
+  }
+  if (!isUvInstalled()) {
+    const uvDep = getDependency("uv");
+    const method = getInstallMethod(uvDep);
+    console.error("uv is required but is not installed.");
+    console.error("  uv is a fast Python package manager used by Claude Code.");
+    const shouldInstall = autoYes || await confirm(`Would you like to install uv via ${method}?`);
+    if (shouldInstall) {
+      const success = installUv();
+      if (!success) {
+        throw new CliError("INSTALL_FAILED", "Failed to install uv", ExitCodes.ERROR);
+      }
+      console.error("uv installed successfully!");
+    } else {
+      throw new CliError("MISSING_DEPENDENCY", `uv is required. Install manually: ${getInstallCommand(uvDep)}`, ExitCodes.ERROR);
     }
   }
   const existingPid = readPid();
   if (existingPid && isProcessRunning(existingPid)) {
     console.error(`Vibora server is already running (PID: ${existingPid})`);
-    const shouldReplace = await confirm("Would you like to stop it and start a new instance?");
+    const shouldReplace = autoYes || await confirm("Would you like to stop it and start a new instance?");
     if (shouldReplace) {
       console.error("Stopping existing instance...");
       process.kill(existingPid, "SIGTERM");
@@ -30309,6 +30485,23 @@ async function handleUpCommand(flags) {
     port,
     url: `http://localhost:${port}`
   });
+  showGettingStartedTips(port);
+}
+function showGettingStartedTips(port) {
+  console.error(`
+Vibora is running at http://localhost:${port}
+
+Getting Started:
+  1. Open http://localhost:${port} in your browser
+  2. Add a repository to get started
+  3. Create a task to spin up an isolated worktree
+  4. Run Claude Code in the task terminal
+
+Commands:
+  vibora status    Check server status
+  vibora doctor    Check all dependencies
+  vibora down      Stop the server
+`);
 }
 
 // cli/src/commands/down.ts
@@ -30587,9 +30780,71 @@ async function handleDevCommand(action, flags) {
   }
 }
 
+// cli/src/commands/doctor.ts
+async function handleDoctorCommand(flags) {
+  const deps = checkAllDependencies();
+  const showJson = !isPrettyOutput() && flags.pretty !== "true";
+  if (showJson) {
+    output(deps);
+    return;
+  }
+  console.log(`
+Vibora Doctor`);
+  console.log(`=============
+`);
+  console.log("Required:");
+  for (const dep of deps.filter((d) => d.required)) {
+    const icon = dep.installed ? "\u2713" : "\u2717";
+    const version2 = dep.version || "-";
+    console.log(`  ${icon} ${dep.name.padEnd(10)} ${version2.padEnd(20)} ${dep.description}`);
+  }
+  console.log(`
+Optional:`);
+  for (const dep of deps.filter((d) => !d.required)) {
+    const icon = dep.installed ? "\u2713" : "\u25CB";
+    const version2 = dep.version || "-";
+    console.log(`  ${icon} ${dep.name.padEnd(10)} ${version2.padEnd(20)} ${dep.description}`);
+  }
+  const requiredDeps = deps.filter((d) => d.required);
+  const requiredInstalled = requiredDeps.filter((d) => d.installed).length;
+  const requiredTotal = requiredDeps.length;
+  console.log(`
+Status: ${requiredInstalled} of ${requiredTotal} required dependencies installed`);
+  const requiredMissing = requiredDeps.filter((d) => !d.installed);
+  if (requiredMissing.length > 0) {
+    console.log(`
+Missing required dependencies:`);
+    for (const dep of requiredMissing) {
+      const fullDep = getDependency(dep.name);
+      if (fullDep) {
+        console.log(`  ${dep.name}: ${getInstallCommand(fullDep)}`);
+      }
+    }
+    console.log("\nRun `vibora up` to install missing dependencies.");
+  } else {
+    console.log(`
+\u2713 All required dependencies installed!`);
+  }
+  const optionalMissing = deps.filter((d) => !d.required && !d.installed);
+  if (optionalMissing.length > 0) {
+    console.log(`
+Optional dependencies not installed:`);
+    for (const dep of optionalMissing) {
+      const fullDep = getDependency(dep.name);
+      if (fullDep) {
+        console.log(`  ${dep.name}: ${getInstallCommand(fullDep)}`);
+      }
+    }
+  }
+  console.log("");
+}
+
 // cli/src/index.ts
 init_errors();
 var VERSION = "0.1.0";
+var FLAG_ALIASES = {
+  y: "yes"
+};
 function parseArgs(args) {
   const positional = [];
   const flags = {};
@@ -30604,13 +30859,17 @@ function parseArgs(args) {
       } else {
         const key = arg.slice(2);
         const nextArg = args[i + 1];
-        if (nextArg && !nextArg.startsWith("--")) {
+        if (nextArg && !nextArg.startsWith("-")) {
           flags[key] = nextArg;
           i++;
         } else {
           flags[key] = "true";
         }
       }
+    } else if (arg.startsWith("-") && arg.length === 2) {
+      const shortKey = arg.slice(1);
+      const longKey = FLAG_ALIASES[shortKey] || shortKey;
+      flags[longKey] = "true";
     } else {
       positional.push(arg);
     }
@@ -30649,9 +30908,12 @@ Commands:
   tasks move <id>           Move task to different status
   tasks delete <id>         Delete a task
 
-  up [--host] [--debug]     Start Vibora server (daemon)
+  up [-y] [--host] [--debug]
+                            Start Vibora server (daemon)
+                            Checks/installs dependencies: bun, dtach, claude, uv
   down                      Stop Vibora server
   status                    Check if server is running
+  doctor                    Check all dependencies and show versions
 
   git status                Get git status for worktree
   git diff                  Get git diff for worktree
@@ -30683,6 +30945,7 @@ Global Options:
   --port=<port>     Server port (default: 7777)
   --url=<url>       Override full server URL
   --pretty          Pretty-print JSON output
+  -y, --yes         Auto-confirm prompts (for CI/automation)
   --version         Show version
   --help            Show this help
 
@@ -30737,6 +31000,10 @@ Examples:
         await handleHealthCommand(flags);
         break;
       }
+      case "doctor": {
+        await handleDoctorCommand(flags);
+        break;
+      }
       case "notifications": {
         const [action, ...notificationsRest] = rest;
         await handleNotificationsCommand(action, notificationsRest, flags);