@a3t/rapid 0.1.7 → 0.1.9

package/dist/{chunk-FICHP3SD.js → chunk-C6XSZWFT.js}

@@ -1,14 +1,15 @@
 // src/index.ts
-import { Command as Command10 } from "commander";
-import { setLogLevel, logger as logger10 } from "@a3t/rapid-core";
-import { readFileSync } from "fs";
-import { fileURLToPath } from "url";
-import { dirname, join as join4 } from "path";
+import { Command as Command13 } from "commander";
+import { setLogLevel, logger as logger14 } from "@a3t/rapid-core";
+import { readFileSync as readFileSync2 } from "fs";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { dirname as dirname4, join as join7 } from "path";
 
 // src/commands/init.ts
 import { Command } from "commander";
-import { writeFile, access, readFile, readdir } from "fs/promises";
+import { writeFile, access, readFile, readdir, mkdir } from "fs/promises";
 import { join } from "path";
+import { existsSync } from "fs";
 import {
   getDefaultConfig,
   logger,
@@ -195,7 +196,283 @@ async function downloadRemoteTemplate(parsed, destDir, spinner) {
     return false;
   }
 }
-var initCommand = new Command("init").description("Initialize RAPID in a project").argument("[template]", "Template: builtin name, github:user/repo, npm:package, or URL").option("--force", "Overwrite existing files", false).option("--agent <name>", "Default agent to configure", "claude").option("--no-devcontainer", "Skip devcontainer creation").option("--mcp <servers>", "MCP servers to enable (comma-separated)", "context7,tavily").option("--no-mcp", "Skip MCP server configuration").option("--no-detect", "Skip auto-detection of project type").action(async (templateArg, options) => {
+var PREBUILT_IMAGE_REGISTRY = "ghcr.io/a3tai/rapid-devcontainer";
+var PREBUILT_IMAGES = {
+  typescript: `${PREBUILT_IMAGE_REGISTRY}-typescript:latest`,
+  javascript: `${PREBUILT_IMAGE_REGISTRY}-typescript:latest`,
+  python: `${PREBUILT_IMAGE_REGISTRY}-python:latest`,
+  rust: `${PREBUILT_IMAGE_REGISTRY}-rust:latest`,
+  go: `${PREBUILT_IMAGE_REGISTRY}-go:latest`,
+  universal: `${PREBUILT_IMAGE_REGISTRY}-universal:latest`,
+  infrastructure: `${PREBUILT_IMAGE_REGISTRY}-infrastructure:latest`
+};
+var TEMPLATE_CUSTOMIZATIONS = {
+  typescript: {
+    vscode: {
+      extensions: [
+        "dbaeumer.vscode-eslint",
+        "esbenp.prettier-vscode",
+        "bradlc.vscode-tailwindcss",
+        "prisma.prisma",
+        "mikestead.dotenv"
+      ],
+      settings: {
+        "editor.formatOnSave": true,
+        "editor.defaultFormatter": "esbenp.prettier-vscode"
+      }
+    }
+  },
+  python: {
+    vscode: {
+      extensions: [
+        "ms-python.python",
+        "ms-python.vscode-pylance",
+        "charliermarsh.ruff",
+        "ms-toolsai.jupyter"
+      ],
+      settings: {
+        "[python]": {
+          "editor.formatOnSave": true,
+          "editor.defaultFormatter": "charliermarsh.ruff"
+        }
+      }
+    }
+  },
+  rust: {
+    vscode: {
+      extensions: ["rust-lang.rust-analyzer", "tamasfe.even-better-toml", "vadimcn.vscode-lldb"],
+      settings: { "[rust]": { "editor.formatOnSave": true } }
+    }
+  },
+  go: {
+    vscode: {
+      extensions: ["golang.go", "zxh404.vscode-proto3"],
+      settings: { "[go]": { "editor.formatOnSave": true } }
+    }
+  },
+  universal: {
+    vscode: {
+      extensions: [
+        "dbaeumer.vscode-eslint",
+        "esbenp.prettier-vscode",
+        "ms-python.python",
+        "golang.go"
+      ]
+    }
+  },
+  infrastructure: {
+    vscode: {
+      extensions: [
+        "hashicorp.terraform",
+        "ms-kubernetes-tools.vscode-kubernetes-tools",
+        "redhat.vscode-yaml"
+      ]
+    }
+  }
+};
+function getPrebuiltConfig(templateName, containerEnv, postStartCommand) {
+  const image = PREBUILT_IMAGES[templateName] ?? PREBUILT_IMAGES.universal;
+  const customizations = TEMPLATE_CUSTOMIZATIONS[templateName] ?? TEMPLATE_CUSTOMIZATIONS.universal;
+  const remoteUser = templateName === "typescript" ? "node" : "vscode";
+  return {
+    name: `RAPID ${templateName.charAt(0).toUpperCase() + templateName.slice(1)} (Pre-built)`,
+    image,
+    customizations,
+    containerEnv,
+    postStartCommand,
+    remoteUser
+  };
+}
+function getDevContainerConfig(detected, usePrebuilt = false) {
+  const baseFeatures = {
+    "ghcr.io/devcontainers/features/git:1": {},
+    "ghcr.io/devcontainers-contrib/features/direnv:1": {},
+    "ghcr.io/devcontainers-contrib/features/starship:1": {},
+    "ghcr.io/devcontainers-contrib/features/1password-cli:1": {}
+  };
+  const containerEnv = {
+    OP_SERVICE_ACCOUNT_TOKEN: "${localEnv:OP_SERVICE_ACCOUNT_TOKEN}"
+  };
+  const postCreateBase = "npm install -g @anthropic-ai/claude-code && curl -fsSL https://opencode.ai/install | bash";
+  const postStartCommand = "direnv allow 2>/dev/null || true";
+  const language = detected?.language || "unknown";
+  const templateName = language === "javascript" ? "typescript" : language === "unknown" ? "universal" : language;
+  if (usePrebuilt && PREBUILT_IMAGES[templateName]) {
+    return getPrebuiltConfig(templateName, containerEnv, postStartCommand);
+  }
+  switch (language) {
+    case "typescript":
+    case "javascript":
+      return {
+        name: "RAPID TypeScript",
+        image: "mcr.microsoft.com/devcontainers/typescript-node:22",
+        features: {
+          ...baseFeatures,
+          "ghcr.io/devcontainers-contrib/features/pnpm:2": {}
+        },
+        customizations: {
+          vscode: {
+            extensions: [
+              "dbaeumer.vscode-eslint",
+              "esbenp.prettier-vscode",
+              "bradlc.vscode-tailwindcss",
+              "prisma.prisma",
+              "mikestead.dotenv"
+            ],
+            settings: {
+              "editor.formatOnSave": true,
+              "editor.defaultFormatter": "esbenp.prettier-vscode",
+              "editor.codeActionsOnSave": {
+                "source.fixAll.eslint": "explicit"
+              }
+            }
+          }
+        },
+        containerEnv,
+        postCreateCommand: postCreateBase,
+        postStartCommand,
+        remoteUser: "node"
+      };
+    case "python":
+      return {
+        name: "RAPID Python",
+        image: "mcr.microsoft.com/devcontainers/python:3.12",
+        features: {
+          ...baseFeatures,
+          "ghcr.io/devcontainers/features/node:1": { version: "22" },
+          "ghcr.io/devcontainers-contrib/features/poetry:2": {},
+          "ghcr.io/devcontainers-contrib/features/uv:1": {}
+        },
+        customizations: {
+          vscode: {
+            extensions: [
+              "ms-python.python",
+              "ms-python.vscode-pylance",
+              "ms-python.debugpy",
+              "charliermarsh.ruff",
+              "ms-toolsai.jupyter",
+              "tamasfe.even-better-toml"
+            ],
+            settings: {
+              "python.defaultInterpreterPath": "/usr/local/bin/python",
+              "[python]": {
+                "editor.formatOnSave": true,
+                "editor.defaultFormatter": "charliermarsh.ruff",
+                "editor.codeActionsOnSave": {
+                  "source.fixAll": "explicit",
+                  "source.organizeImports": "explicit"
+                }
+              }
+            }
+          }
+        },
+        containerEnv,
+        postCreateCommand: `${postCreateBase} && pip install aider-chat`,
+        postStartCommand,
+        remoteUser: "vscode"
+      };
+    case "rust":
+      return {
+        name: "RAPID Rust",
+        image: "mcr.microsoft.com/devcontainers/rust:latest",
+        features: {
+          ...baseFeatures,
+          "ghcr.io/devcontainers/features/node:1": { version: "22" }
+        },
+        customizations: {
+          vscode: {
+            extensions: [
+              "rust-lang.rust-analyzer",
+              "tamasfe.even-better-toml",
+              "serayuzgur.crates",
+              "vadimcn.vscode-lldb"
+            ],
+            settings: {
+              "rust-analyzer.checkOnSave.command": "clippy",
+              "[rust]": {
+                "editor.formatOnSave": true,
+                "editor.defaultFormatter": "rust-lang.rust-analyzer"
+              }
+            }
+          }
+        },
+        containerEnv,
+        postCreateCommand: `${postCreateBase} && rustup component add clippy rustfmt`,
+        postStartCommand,
+        remoteUser: "vscode"
+      };
+    case "go":
+      return {
+        name: "RAPID Go",
+        image: "mcr.microsoft.com/devcontainers/go:1.23",
+        features: {
+          ...baseFeatures,
+          "ghcr.io/devcontainers/features/node:1": { version: "22" }
+        },
+        customizations: {
+          vscode: {
+            extensions: ["golang.go", "zxh404.vscode-proto3", "tamasfe.even-better-toml"],
+            settings: {
+              "go.useLanguageServer": true,
+              "go.lintTool": "golangci-lint",
+              "go.lintFlags": ["--fast"],
+              "[go]": {
+                "editor.formatOnSave": true,
+                "editor.codeActionsOnSave": {
+                  "source.organizeImports": "explicit"
+                }
+              }
+            }
+          }
+        },
+        containerEnv,
+        postCreateCommand: `${postCreateBase} && go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest && go install github.com/air-verse/air@latest`,
+        postStartCommand,
+        remoteUser: "vscode"
+      };
+    default:
+      return {
+        name: "RAPID Universal",
+        image: "mcr.microsoft.com/devcontainers/base:ubuntu",
+        features: {
+          ...baseFeatures,
+          "ghcr.io/devcontainers/features/node:1": { version: "22" },
+          "ghcr.io/devcontainers/features/python:1": { version: "3.12" },
+          "ghcr.io/devcontainers/features/go:1": { version: "1.23" },
+          "ghcr.io/devcontainers/features/docker-in-docker:2": {}
+        },
+        customizations: {
+          vscode: {
+            extensions: [
+              "dbaeumer.vscode-eslint",
+              "esbenp.prettier-vscode",
+              "ms-python.python",
+              "ms-python.vscode-pylance",
+              "golang.go",
+              "tamasfe.even-better-toml",
+              "redhat.vscode-yaml"
+            ]
+          }
+        },
+        containerEnv,
+        postCreateCommand: `${postCreateBase} && pip install aider-chat`,
+        postStartCommand,
+        remoteUser: "vscode"
+      };
+  }
+}
+async function createDevContainer(dir, detected, force = false, usePrebuilt = false) {
+  const devcontainerDir = join(dir, ".devcontainer");
+  const devcontainerJsonPath = join(devcontainerDir, "devcontainer.json");
+  if (!force && existsSync(devcontainerJsonPath)) {
+    return false;
+  }
+  await mkdir(devcontainerDir, { recursive: true });
+  const config = getDevContainerConfig(detected, usePrebuilt);
+  await writeFile(devcontainerJsonPath, JSON.stringify(config, null, 2) + "\n");
+  return true;
+}
+var initCommand = new Command("init").description("Initialize RAPID in a project").argument("[template]", "Template: builtin name, github:user/repo, npm:package, or URL").option("--force", "Overwrite existing files", false).option("--agent <name>", "Default agent to configure", "claude").option("--no-devcontainer", "Skip devcontainer creation").option("--prebuilt", "Use pre-built devcontainer images from ghcr.io (faster startup)", false).option("--mcp <servers>", "MCP servers to enable (comma-separated)", "context7,tavily").option("--no-mcp", "Skip MCP server configuration").option("--no-detect", "Skip auto-detection of project type").action(async (templateArg, options) => {
   const spinner = ora("Initializing RAPID...").start();
   try {
     const cwd = process.cwd();
@@ -290,6 +567,17 @@ var initCommand = new Command("init").description("Initialize RAPID in a project
     spinner.text = "Creating AGENTS.md...";
     const agentsMdPath = join(cwd, "AGENTS.md");
     await writeFile(agentsMdPath, getAgentsMdTemplate(cwd, detectedProject));
+    let devcontainerCreated = false;
+    const usePrebuilt = options.prebuilt === true;
+    if (options.devcontainer !== false) {
+      spinner.text = usePrebuilt ? "Creating devcontainer configuration (using pre-built image)..." : "Creating devcontainer configuration...";
+      devcontainerCreated = await createDevContainer(
+        cwd,
+        detectedProject,
+        options.force,
+        usePrebuilt
+      );
+    }
     spinner.succeed("RAPID initialized successfully!");
     if (detectedProject && detectedProject.language !== "unknown") {
       logger.blank();
@@ -309,6 +597,9 @@ var initCommand = new Command("init").description("Initialize RAPID in a project
       console.log(`  ${logger.dim("\u2022")} .mcp.json`);
       console.log(`  ${logger.dim("\u2022")} opencode.json`);
     }
+    if (devcontainerCreated) {
+      console.log(`  ${logger.dim("\u2022")} .devcontainer/devcontainer.json`);
+    }
     console.log(`  ${logger.dim("\u2022")} CLAUDE.md`);
     console.log(`  ${logger.dim("\u2022")} AGENTS.md`);
     if (mcpServers.length > 0) {
@@ -323,11 +614,21 @@ var initCommand = new Command("init").description("Initialize RAPID in a project
     }
     logger.blank();
     logger.info("Next steps:");
-    console.log(`  ${logger.dim("1.")} Run ${logger.brand("rapid dev")} to start coding`);
-    console.log(`  ${logger.dim("2.")} Edit ${logger.dim("rapid.json")} to customize your setup`);
+    let stepNum = 1;
+    console.log(
+      `  ${logger.dim(`${stepNum++}.`)} Run ${logger.brand("rapid dev")} to start coding`
+    );
+    console.log(
+      `  ${logger.dim(`${stepNum++}.`)} Edit ${logger.dim("rapid.json")} to customize your setup`
+    );
     if (mcpServers.length > 0) {
       console.log(
-        `  ${logger.dim("3.")} Add API keys to ${logger.dim("secrets.items")} in rapid.json`
+        `  ${logger.dim(`${stepNum++}.`)} Add API keys to ${logger.dim("secrets.items")} in rapid.json`
+      );
+    }
+    if (devcontainerCreated) {
+      console.log(
+        `  ${logger.dim(`${stepNum++}.`)} Set ${logger.dim("OP_SERVICE_ACCOUNT_TOKEN")} env var for 1Password secrets`
       );
     }
     logger.blank();
@@ -449,8 +750,8 @@ ${GIT_GUIDELINES}
 
 // src/commands/dev.ts
 import { Command as Command2 } from "commander";
-import { writeFile as writeFile2 } from "fs/promises";
-import { isAbsolute, join as join2 } from "path";
+import { writeFile as writeFile3 } from "fs/promises";
+import { isAbsolute, join as join4 } from "path";
 import {
   loadConfig,
   getAgent,
@@ -469,10 +770,547 @@ import {
   agentSupportsRuntimeInjection
 } from "@a3t/rapid-core";
 import ora2 from "ora";
+
+// src/utils/worktree.ts
+import { execa } from "execa";
+import { access as access2 } from "fs/promises";
+import { basename, dirname, join as join2, resolve } from "path";
+function getErrorMessage(err) {
+  if (typeof err.stderr === "string" && err.stderr) {
+    return err.stderr;
+  }
+  return err.message;
+}
+async function isGitRepo(dir) {
+  try {
+    await execa("git", ["rev-parse", "--git-dir"], { cwd: dir });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getGitRoot(dir) {
+  const { stdout } = await execa("git", ["rev-parse", "--show-toplevel"], { cwd: dir });
+  return stdout.trim();
+}
+async function getCurrentBranch(dir) {
+  try {
+    const { stdout: symbolicRef } = await execa("git", ["symbolic-ref", "-q", "HEAD"], {
+      cwd: dir,
+      reject: false
+    });
+    if (!symbolicRef) {
+      return { name: null, isDefault: false, detached: true };
+    }
+    const branchName = symbolicRef.trim().replace("refs/heads/", "");
+    const isDefault = branchName === "main" || branchName === "master";
+    return { name: branchName, isDefault, detached: false };
+  } catch {
+    return { name: null, isDefault: false, detached: true };
+  }
+}
+async function getDefaultBranch(dir) {
+  try {
+    const { stdout } = await execa("git", ["symbolic-ref", "refs/remotes/origin/HEAD", "--short"], {
+      cwd: dir,
+      reject: false
+    });
+    if (stdout) {
+      return stdout.trim().replace("origin/", "");
+    }
+    const { stdout: branches } = await execa("git", ["branch", "--list", "main", "master"], {
+      cwd: dir
+    });
+    if (branches.includes("main")) return "main";
+    if (branches.includes("master")) return "master";
+    return "main";
+  } catch {
+    return "main";
+  }
+}
+async function listWorktrees(dir) {
+  const { stdout } = await execa("git", ["worktree", "list", "--porcelain"], { cwd: dir });
+  const worktrees = [];
+  let current = {};
+  for (const line of stdout.split("\n")) {
+    if (line.startsWith("worktree ")) {
+      if (current.path) {
+        worktrees.push(current);
+      }
+      current = {
+        path: line.substring(9),
+        isMain: false,
+        locked: false,
+        exists: true,
+        prunable: false
+      };
+    } else if (line.startsWith("HEAD ")) {
+      current.head = line.substring(5);
+    } else if (line.startsWith("branch ")) {
+      current.branch = line.substring(7).replace("refs/heads/", "");
+    } else if (line === "bare") {
+      current.isMain = true;
+    } else if (line === "locked") {
+      current.locked = true;
+    } else if (line === "prunable") {
+      current.prunable = true;
+      current.exists = false;
+    } else if (line === "detached") {
+      current.branch = null;
+    }
+  }
+  if (current.path) {
+    worktrees.push(current);
+  }
+  if (worktrees.length > 0 && worktrees[0]) {
+    worktrees[0].isMain = true;
+  }
+  for (const wt of worktrees) {
+    try {
+      await access2(wt.path);
+      wt.exists = true;
+    } catch {
+      wt.exists = false;
+      wt.prunable = true;
+    }
+  }
+  return worktrees;
+}
+async function findWorktreeByBranch(dir, branch) {
+  const worktrees = await listWorktrees(dir);
+  return worktrees.find((wt) => wt.branch === branch) ?? null;
+}
+function generateWorktreePath(repoRoot, branchName) {
+  const projectName = basename(repoRoot);
+  const parentDir = dirname(repoRoot);
+  const safeBranchName = branchName.replace(/\//g, "-").replace(/[^a-zA-Z0-9-_]/g, "").toLowerCase();
+  return join2(parentDir, `${projectName}-${safeBranchName}`);
+}
+async function createWorktree(repoRoot, worktreePath, branch, options = {}) {
+  try {
+    const existing = await listWorktrees(repoRoot);
+    const existingAtPath = existing.find((wt) => resolve(wt.path) === resolve(worktreePath));
+    if (existingAtPath && existingAtPath.exists && !options.force) {
+      return { success: true, path: worktreePath };
+    }
+    if (existingAtPath && !existingAtPath.exists) {
+      await execa("git", ["worktree", "remove", "--force", worktreePath], {
+        cwd: repoRoot,
+        reject: false
+      });
+    }
+    const args = ["worktree", "add"];
+    if (options.force) {
+      args.push("--force");
+    }
+    if (options.newBranch) {
+      args.push("-b", options.newBranch);
+    }
+    args.push(worktreePath);
+    if (!options.newBranch) {
+      args.push(branch);
+    } else if (options.startPoint) {
+      args.push(options.startPoint);
+    }
+    await execa("git", args, { cwd: repoRoot });
+    return { success: true, path: worktreePath };
+  } catch (err) {
+    const error = err;
+    return {
+      success: false,
+      path: worktreePath,
+      error: getErrorMessage(error)
+    };
+  }
+}
+async function removeWorktree(repoRoot, worktreePath, options = {}) {
+  try {
+    const args = ["worktree", "remove"];
+    if (options.force) {
+      args.push("--force");
+    }
+    args.push(worktreePath);
+    await execa("git", args, { cwd: repoRoot });
+    return { success: true };
+  } catch (err) {
+    const error = err;
+    return {
+      success: false,
+      error: getErrorMessage(error)
+    };
+  }
+}
+async function pruneWorktrees(repoRoot) {
+  try {
+    const worktrees = await listWorktrees(repoRoot);
+    const prunable = worktrees.filter((wt) => wt.prunable).map((wt) => wt.path);
+    await execa("git", ["worktree", "prune"], { cwd: repoRoot });
+    return { success: true, pruned: prunable };
+  } catch (err) {
+    const error = err;
+    return {
+      success: false,
+      pruned: [],
+      error: getErrorMessage(error)
+    };
+  }
+}
+async function getOrCreateWorktreeForBranch(dir) {
+  const gitRoot = await getGitRoot(dir);
+  const branch = await getCurrentBranch(dir);
+  if (branch.isDefault || branch.detached || !branch.name) {
+    return { path: gitRoot, created: false, isMain: true };
+  }
+  const existing = await findWorktreeByBranch(gitRoot, branch.name);
+  if (existing && existing.exists) {
+    return { path: existing.path, created: false, isMain: existing.isMain };
+  }
+  const worktreePath = generateWorktreePath(gitRoot, branch.name);
+  const result = await createWorktree(gitRoot, worktreePath, branch.name);
+  if (!result.success) {
+    return { path: gitRoot, created: false, isMain: true };
+  }
+  return { path: worktreePath, created: true, isMain: false };
+}
+async function cleanupMergedWorktrees(repoRoot) {
+  const removed = [];
+  const errors = [];
+  const defaultBranch = await getDefaultBranch(repoRoot);
+  const { stdout } = await execa("git", ["branch", "--merged", defaultBranch], { cwd: repoRoot });
+  const mergedBranches = stdout.split("\n").map((b) => b.trim().replace(/^\*\s*/, "")).filter((b) => b && b !== defaultBranch);
+  const worktrees = await listWorktrees(repoRoot);
+  for (const wt of worktrees) {
+    if (wt.isMain || !wt.branch) continue;
+    if (mergedBranches.includes(wt.branch)) {
+      const result = await removeWorktree(repoRoot, wt.path, { force: true });
+      if (result.success) {
+        removed.push(wt.path);
+      } else if (result.error) {
+        errors.push(`${wt.path}: ${result.error}`);
+      }
+    }
+  }
+  return { removed, errors };
+}
+
+// src/isolation/lima.ts
+import { execa as execa2 } from "execa";
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { homedir, platform } from "os";
+import { join as join3, dirname as dirname2 } from "path";
+import { fileURLToPath } from "url";
+function getErrorMessage2(err) {
+  if (typeof err.stderr === "string" && err.stderr) {
+    return err.stderr;
+  }
+  return err.message;
+}
+function getOutputString(output) {
+  if (typeof output === "string") {
+    return output;
+  }
+  return void 0;
+}
+var RAPID_LIMA_INSTANCE = "rapid";
+var RAPID_LIMA_DIR = join3(homedir(), ".rapid", "lima");
+async function hasLima() {
+  try {
+    await execa2("limactl", ["--version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isMacOS() {
+  return platform() === "darwin";
+}
+function getLimaTemplatePath() {
+  const __dirname3 = dirname2(fileURLToPath(import.meta.url));
+  const possiblePaths = [
+    join3(__dirname3, "../../../../templates/lima.yaml"),
+    // From dist/isolation/
+    join3(__dirname3, "../../../templates/lima.yaml"),
+    // From src/isolation/
+    join3(homedir(), ".rapid", "lima.yaml")
+    // User config
+  ];
+  return possiblePaths[0];
+}
+async function listInstances() {
+  try {
+    const { stdout } = await execa2("limactl", ["list", "--json"]);
+    const instances = JSON.parse(stdout);
+    return instances.map((inst) => {
+      const result = {
+        name: inst.name,
+        status: inst.status,
+        arch: inst.arch,
+        cpus: inst.cpus,
+        memory: `${Math.round(inst.memory / 1024 / 1024 / 1024)}GiB`,
+        disk: `${Math.round(inst.disk / 1024 / 1024 / 1024)}GiB`,
+        dir: inst.dir
+      };
+      if (inst.sshLocalPort !== void 0) {
+        result.sshLocalPort = inst.sshLocalPort;
+      }
+      return result;
+    });
+  } catch {
+    return [];
+  }
+}
+async function getInstance(name = RAPID_LIMA_INSTANCE) {
+  const instances = await listInstances();
+  return instances.find((i) => i.name === name) ?? null;
+}
+async function instanceExists(name = RAPID_LIMA_INSTANCE) {
+  const instance = await getInstance(name);
+  return instance !== null;
+}
+async function isRunning(name = RAPID_LIMA_INSTANCE) {
+  const instance = await getInstance(name);
+  return instance?.status === "Running";
+}
+function insertProjectMount(config, projectDir) {
+  const projectMount = `  - location: "${projectDir}"
+    writable: true
+`;
+  const homeMountRegex = /mounts:\s*\n(\s*- location: ['"]~['"]\n(?:\s{2,}[^-][^\n]*\n)*)/;
+  return config.replace(homeMountRegex, (_match, homeMount) => {
+    return `mounts:
+${homeMount}${projectMount}`;
+  });
+}
+async function createLimaConfig(projectDir, options = {}) {
+  const templatePath = getLimaTemplatePath();
+  const configDir = RAPID_LIMA_DIR;
+  const configPath = join3(configDir, "lima.yaml");
+  await mkdir2(configDir, { recursive: true });
+  let template;
+  try {
+    template = await readFile2(templatePath, "utf-8");
+  } catch {
+    template = getMinimalLimaConfig();
+  }
+  let config = template;
+  config = insertProjectMount(config, projectDir);
+  if (options.cpus) {
+    config = config.replace(/cpus: \d+/, `cpus: ${options.cpus}`);
+  }
+  if (options.memory) {
+    config = config.replace(/memory: "[^"]*"/, `memory: "${options.memory}"`);
+  }
+  if (options.disk) {
+    config = config.replace(/disk: "[^"]*"/, `disk: "${options.disk}"`);
+  }
+  if (options.env) {
+    const envLines = Object.entries(options.env).map(([key, value]) => `  ${key}: "${value}"`).join("\n");
+    config = config.replace(/env:[\s\S]*?(?=\n\w|\n#|$)/, `env:
+${envLines}
+`);
+  }
+  await writeFile2(configPath, config);
+  return configPath;
+}
+function getMinimalLimaConfig() {
+  return `
+vmType: "vz"
+vmOpts:
+  vz:
+    rosetta:
+      enabled: true
+      binfmt: true
+
+cpus: 4
+memory: "8GiB"
+disk: "50GiB"
+images:
+  - location: "https://cloud-images.ubuntu.com/releases/24.04/release/ubuntu-24.04-server-cloudimg-arm64.img"
+    arch: "aarch64"
+  - location: "https://cloud-images.ubuntu.com/releases/24.04/release/ubuntu-24.04-server-cloudimg-amd64.img"
+    arch: "x86_64"
+mountType: "virtiofs"
+mounts:
+  - location: "~"
+    writable: true
+mountInotify: true
+ssh:
+  forwardAgent: true
+  localPort: 0
+networks:
+  - vzNAT: true
+containerd:
+  system: true
+  user: false
+portForwards:
+  - guestPort: 3000
+    hostPort: 3000
+  - guestPort: 8080
+    hostPort: 8080
+provision:
+  - mode: system
+    script: |
+      #!/bin/bash
+      set -eux
+      apt-get update
+      apt-get install -y build-essential curl git jq
+      curl -fsSL https://deb.nodesource.com/setup_22.x | bash -
+      apt-get install -y nodejs
+      npm install -g pnpm
+  - mode: user
+    script: |
+      #!/bin/bash
+      set -eux
+      npm install -g @anthropic-ai/claude-code || true
+      curl -fsSL https://opencode.ai/install | bash || true
+`;
+}
+async function startInstance(projectDir, options = {}) {
+  const name = RAPID_LIMA_INSTANCE;
+  if (!await hasLima()) {
+    return {
+      success: false,
+      error: "Lima is not installed. Install with: brew install lima"
+    };
+  }
+  if (!isMacOS()) {
+    return {
+      success: false,
+      error: "Lima is only available on macOS"
+    };
+  }
+  try {
+    const exists = await instanceExists(name);
+    if (exists) {
+      if (await isRunning(name)) {
+        return { success: true };
+      }
+      await execa2("limactl", ["start", name], {
+        timeout: (options.timeout ?? 300) * 1e3
+      });
+    } else {
+      const configPath = await createLimaConfig(projectDir, options);
+      await execa2("limactl", ["start", "--name", name, configPath], {
+        timeout: (options.timeout ?? 600) * 1e3,
+        stdio: "inherit"
+        // Show progress
+      });
+    }
+    return { success: true };
+  } catch (err) {
+    const error = err;
+    return {
+      success: false,
+      error: getErrorMessage2(error)
+    };
+  }
+}
+async function stopInstance(name = RAPID_LIMA_INSTANCE, options = {}) {
+  try {
+    const args = ["stop"];
+    if (options.force) {
+      args.push("--force");
+    }
+    args.push(name);
+    await execa2("limactl", args);
+    return { success: true };
+  } catch (err) {
+    const error = err;
+    return {
+      success: false,
+      error: getErrorMessage2(error)
+    };
+  }
+}
+async function deleteInstance(name = RAPID_LIMA_INSTANCE, options = {}) {
+  try {
+    const args = ["delete"];
+    if (options.force) {
+      args.push("--force");
+    }
+    args.push(name);
+    await execa2("limactl", args);
+    return { success: true };
+  } catch (err) {
+    const error = err;
+    return {
+      success: false,
+      error: getErrorMessage2(error)
+    };
+  }
+}
+async function execInLima(command, options = {}) {
+  const name = options.name ?? RAPID_LIMA_INSTANCE;
+  try {
+    let fullCommand = command.join(" ");
+    if (options.cwd) {
+      fullCommand = `cd "${options.cwd}" && ${fullCommand}`;
+    }
+    if (options.env) {
+      const exports = Object.entries(options.env).map(([key, value]) => `export ${key}="${value}"`).join(" && ");
+      fullCommand = `${exports} && ${fullCommand}`;
+    }
+    const useInheritStdio = options.interactive || options.tty;
+    const result = await execa2(
+      "limactl",
+      ["shell", name, "--", "bash", "-c", fullCommand],
+      useInheritStdio ? { stdio: "inherit" } : {}
+    );
+    const successResult = {
+      success: true
+    };
+    const stdout = getOutputString(result.stdout);
+    const stderr = getOutputString(result.stderr);
+    if (stdout) successResult.stdout = stdout;
+    if (stderr) successResult.stderr = stderr;
+    return successResult;
+  } catch (err) {
+    const error = err;
+    const errorResult = {
+      success: false,
+      error: error.message
+    };
+    const stdout = getOutputString(error.stdout);
+    const stderr = getOutputString(error.stderr);
+    if (stdout) errorResult.stdout = stdout;
+    if (stderr) errorResult.stderr = stderr;
+    return errorResult;
+  }
+}
+async function shellInLima(options = {}) {
+  const name = options.name ?? RAPID_LIMA_INSTANCE;
+  const args = ["shell", name];
+  if (options.cwd) {
+    args.push("--workdir", options.cwd);
+  }
+  if (options.command) {
+    args.push("--", options.command);
+  }
+  await execa2("limactl", args, { stdio: "inherit" });
+}
+async function setupGitSsh(name = RAPID_LIMA_INSTANCE) {
+  try {
+    const result = await execInLima(["ssh-add", "-l"], { name });
+    if (!result.success) {
+      return {
+        success: false,
+        error: "SSH agent forwarding is not working. Make sure ssh-agent is running on the host."
+      };
+    }
+    return { success: true };
+  } catch (err) {
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+
+// src/commands/dev.ts
 var devCommand = new Command2("dev").description("Launch AI coding session in the dev container").option("-a, --agent <name>", "Agent to use").option(
   "--multi [agents]",
   "Launch multiple agents (comma-separated, or interactive if no value)"
-).option("--list", "List available agents without launching").option("--local", "Run locally instead of in container (not recommended)").option("--no-start", "Do not auto-start container if stopped").action(async (options) => {
+).option("--list", "List available agents without launching").option("--local", "Run locally instead of in container (not recommended)").option("--no-start", "Do not auto-start container if stopped").option("--no-worktree", "Skip automatic worktree creation for feature branches").action(async (options) => {
   try {
     const spinner = ora2("Loading configuration...").start();
     const loaded = await loadConfig();
@@ -480,12 +1318,34 @@ var devCommand = new Command2("dev").description("Launch AI coding session in th
       spinner.fail("No rapid.json found. Run `rapid init` first.");
       process.exit(1);
     }
-    const { config, rootDir } = loaded;
+    const { config } = loaded;
+    let { rootDir } = loaded;
     spinner.succeed("Configuration loaded");
     if (options.list) {
       listAgents(config);
       return;
     }
+    if (options.worktree !== false && await isGitRepo(rootDir)) {
+      const branch = await getCurrentBranch(rootDir);
+      if (!branch.isDefault && !branch.detached && branch.name) {
+        spinner.start(`Checking worktree for branch: ${branch.name}...`);
+        try {
+          const worktree = await getOrCreateWorktreeForBranch(rootDir);
+          if (worktree.created) {
+            spinner.succeed(`Created worktree: ${worktree.path}`);
+            rootDir = worktree.path;
+          } else if (!worktree.isMain) {
+            spinner.succeed(`Using worktree: ${worktree.path}`);
+            rootDir = worktree.path;
+          } else {
+            spinner.info(`Using main directory (branch: ${branch.name})`);
+          }
+        } catch (err) {
+          spinner.warn("Could not create worktree, using main directory");
+          logger2.debug(err instanceof Error ? err.message : String(err));
+        }
+      }
+    }
     if (options.multi !== void 0) {
       await runMultiAgent(config, rootDir, options);
       return;
@@ -625,7 +1485,7 @@ async function prepareMcpEnv(rootDir, mcp) {
     return void 0;
   }
   const configFile = mcp.configFile ?? ".mcp.json";
-  const configPath = isAbsolute(configFile) ? configFile : join2(rootDir, configFile);
+  const configPath = isAbsolute(configFile) ? configFile : join4(rootDir, configFile);
   const servers = {};
   for (const [name, serverConfig] of Object.entries(mcp.servers)) {
     if (!serverConfig || typeof serverConfig !== "object") {
@@ -640,14 +1500,14 @@ async function prepareMcpEnv(rootDir, mcp) {
   if (Object.keys(servers).length === 0) {
     return void 0;
   }
-  await writeFile2(configPath, `${JSON.stringify({ servers }, null, 2)}
+  await writeFile3(configPath, `${JSON.stringify({ servers }, null, 2)}
 `, "utf-8");
   return {
     MCP_CONFIG_FILE: configFile
   };
 }
 async function runLocally(agent, agentName, rootDir, config) {
-  const { execa } = await import("execa");
+  const { execa: execa4 } = await import("execa");
   const status = await checkAgentAvailable(agent);
   if (!status.available) {
     logger2.error(`${agentName} CLI not found locally`);
@@ -720,14 +1580,18 @@ async function runLocally(agent, agentName, rootDir, config) {
   }
   const mcpEnv = await prepareMcpEnv(rootDir, config.mcp);
   const mergedEnv = { ...secrets, ...mcpEnv ?? {} };
+  const builtArgs = buildAgentArgs(agent, { injectSystemPrompt: true });
+  if (isMacOS() && await hasLima()) {
+    await runInLimaVm(agent, agentName, rootDir, builtArgs, mergedEnv);
+    return;
+  }
   logger2.info(`Launching ${logger2.brand(agentName)}...`);
   logger2.dim(`Working directory: ${rootDir}`);
-  const builtArgs = buildAgentArgs(agent, { injectSystemPrompt: true });
   if (agentSupportsRuntimeInjection(agent)) {
     logger2.dim("Injecting RAPID methodology via CLI args");
   }
   logger2.blank();
-  await execa(agent.cli, builtArgs, {
+  await execa4(agent.cli, builtArgs, {
     cwd: rootDir,
     stdio: "inherit",
     env: {
@@ -736,6 +1600,47 @@ async function runLocally(agent, agentName, rootDir, config) {
     }
   });
 }
+async function runInLimaVm(agent, agentName, rootDir, args, env) {
+  const spinner = ora2();
+  if (!await isRunning()) {
+    spinner.start(`Starting Lima VM (${RAPID_LIMA_INSTANCE})...`);
+    const result = await startInstance(rootDir, {
+      env,
+      timeout: 600
+      // 10 minutes for first-time setup
+    });
+    if (!result.success) {
+      spinner.fail("Failed to start Lima VM");
+      logger2.error(result.error ?? "Unknown error");
+      logger2.blank();
+      logger2.info("Falling back to running directly on host...");
+      logger2.blank();
+      const { execa: execa4 } = await import("execa");
+      await execa4(agent.cli, args, {
+        cwd: rootDir,
+        stdio: "inherit",
+        env: {
+          ...process.env,
+          ...env
+        }
+      });
+      return;
+    }
+    spinner.succeed("Lima VM started");
+  } else {
+    logger2.info(`Lima VM (${RAPID_LIMA_INSTANCE}) is running`);
+  }
+  logger2.info(`Launching ${logger2.brand(agentName)} in Lima VM...`);
+  logger2.dim(`Working directory: ${rootDir}`);
+  logger2.dim("SSH agent forwarded for commit signing");
+  logger2.blank();
+  await execInLima([agent.cli, ...args], {
+    cwd: rootDir,
+    env,
+    interactive: true,
+    tty: true
+  });
+}
 function listAgents(config) {
   logger2.header("Available Agents");
   Object.keys(config.agents.available).forEach((name) => {
@@ -802,10 +1707,10 @@ async function runMultiAgent(config, rootDir, options) {
     console.log(`    ${logger2.brand("\u2022")} ${name}`);
   }
   console.log();
-  const { execa } = await import("execa");
+  const { execa: execa4 } = await import("execa");
   let hasTmux = false;
   try {
-    await execa("tmux", ["-V"]);
+    await execa4("tmux", ["-V"]);
     hasTmux = true;
   } catch {
     hasTmux = false;
@@ -816,23 +1721,23 @@ async function runMultiAgent(config, rootDir, options) {
     const sessionName = `rapid-${Date.now()}`;
     const firstAgent = selectedAgents[0];
     const firstCmd = options.local ? `rapid dev --agent ${firstAgent} --local` : `rapid dev --agent ${firstAgent}`;
-    await execa("tmux", ["new-session", "-d", "-s", sessionName, "-n", "rapid", firstCmd], {
+    await execa4("tmux", ["new-session", "-d", "-s", sessionName, "-n", "rapid", firstCmd], {
       cwd: rootDir
     });
     for (let i = 1; i < selectedAgents.length; i++) {
       const agentName = selectedAgents[i];
       const cmd = options.local ? `rapid dev --agent ${agentName} --local` : `rapid dev --agent ${agentName}`;
-      await execa("tmux", ["split-window", "-t", sessionName, "-h", cmd], {
+      await execa4("tmux", ["split-window", "-t", sessionName, "-h", cmd], {
         cwd: rootDir
       });
-      await execa("tmux", ["select-layout", "-t", sessionName, "tiled"]);
+      await execa4("tmux", ["select-layout", "-t", sessionName, "tiled"]);
     }
     logger2.success(`Started ${selectedAgents.length} agents in tmux session: ${sessionName}`);
     console.log();
     logger2.info("Attaching to tmux session...");
     logger2.dim("Press Ctrl+B then D to detach, or Ctrl+B then arrow keys to switch panes");
     console.log();
-    await execa("tmux", ["attach-session", "-t", sessionName], {
+    await execa4("tmux", ["attach-session", "-t", sessionName], {
       stdio: "inherit"
     });
   } else {
@@ -1574,13 +2479,13 @@ secretsCommand.command("run").description("Run a command with secrets loaded int
       }
       console.log();
     }
-    const { execa } = await import("execa");
+    const { execa: execa4 } = await import("execa");
     const [cmd, ...args] = commandArgs;
     if (!cmd) {
       logger7.error("No command specified");
       process.exit(1);
     }
-    await execa(cmd, args, {
+    await execa4(cmd, args, {
       stdio: "inherit",
       env: {
         ...process.env,
@@ -1783,8 +2688,8 @@ authCommand.command("env").description("Show environment variables for detected
 
 // src/commands/mcp.ts
 import { Command as Command9 } from "commander";
-import { writeFile as writeFile3 } from "fs/promises";
-import { join as join3 } from "path";
+import { writeFile as writeFile4 } from "fs/promises";
+import { join as join5 } from "path";
 import {
   loadConfig as loadConfig7,
   logger as logger9,
@@ -1805,8 +2710,8 @@ var mcpCommand = new Command9("mcp").description(
   "Manage MCP (Model Context Protocol) servers"
 );
 async function saveConfig(rootDir, config) {
-  const configPath = join3(rootDir, "rapid.json");
-  await writeFile3(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  const configPath = join5(rootDir, "rapid.json");
+  await writeFile4(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
 mcpCommand.command("list").description("List configured MCP servers").option("--json", "Output as JSON").option("--templates", "Show available templates instead of configured servers").action(async (options) => {
   try {
@@ -2092,18 +2997,606 @@ function collectHeaders(value, previous) {
   return previous;
 }
 
+// src/commands/update.ts
+import { Command as Command10 } from "commander";
+
+// src/utils/update-checker.ts
+import updateNotifier from "update-notifier";
+import semver from "semver";
+import { execa as execa3 } from "execa";
+import { logger as logger10 } from "@a3t/rapid-core";
+import chalk from "chalk";
+import { readFileSync, existsSync as existsSync2 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname3, join as join6 } from "path";
+import prompts from "prompts";
+var __dirname = dirname3(fileURLToPath2(import.meta.url));
+function loadPackageJson() {
+  const paths = [
+    join6(__dirname, "../package.json"),
+    // bundled: dist/ -> package root
+    join6(__dirname, "../../package.json")
+    // source: src/utils/ -> package root
+  ];
+  for (const p of paths) {
+    if (existsSync2(p)) {
+      return JSON.parse(readFileSync(p, "utf-8"));
+    }
+  }
+  return { name: "@a3t/rapid", version: "0.0.0" };
+}
+var packageJson = loadPackageJson();
+var UpdateChecker = class {
+  notifier;
+  packageName = packageJson.name;
+  constructor() {
+    this.notifier = updateNotifier({
+      pkg: packageJson,
+      updateCheckInterval: 1e3 * 60 * 60 * 24,
+      // Check daily
+      shouldNotifyInNpmScript: true
+    });
+  }
+  /**
+   * Check if an update is available
+   */
+  hasUpdate() {
+    return !!this.notifier.update;
+  }
+  /**
+   * Get update information
+   */
+  getUpdateInfo() {
+    if (!this.notifier.update) return null;
+    return {
+      current: this.notifier.update.current,
+      latest: this.notifier.update.latest,
+      type: this.getUpdateType(this.notifier.update.current, this.notifier.update.latest)
+    };
+  }
+  /**
+   * Determine the type of update (major, minor, patch)
+   */
+  getUpdateType(current, latest) {
+    const diff = semver.diff(current, latest);
+    if (diff === "premajor" || diff === "preminor" || diff === "prepatch") {
+      return "prerelease";
+    }
+    return diff || "patch";
+  }
+  /**
+   * Show update notification
+   */
+  showNotification() {
+    if (!this.notifier.update) return;
+    const { current, latest } = this.notifier.update;
+    const updateType = this.getUpdateType(current, latest);
+    logger10.info(`Update available: ${logger10.dim(current)} \u2192 ${chalk.green(latest)}`);
+    if (updateType === "major") {
+      logger10.warn("This is a major version update with breaking changes.");
+    }
+  }
+  /**
+   * Verify package signatures using npm audit signatures
+   */
+  async verifySignatures() {
+    try {
+      logger10.info("Verifying package signatures...");
+      const result = await execa3("npm", ["audit", "signatures"], {
+        reject: false
+      });
+      if (result.exitCode === 0) {
+        logger10.success("Package signatures verified successfully");
+        return true;
+      } else {
+        logger10.warn("Package signature verification returned warnings");
+        logger10.debug(result.stdout || result.stderr);
+        return true;
+      }
+    } catch {
+      logger10.debug("Signature verification not available (requires npm >= 9)");
+      return true;
+    }
+  }
+  /**
+   * Perform the update with signature verification
+   */
+  async performUpdate() {
+    try {
+      logger10.info("Updating RAPID CLI...");
+      await execa3("npm", ["install", "-g", `${this.packageName}@latest`], {
+        stdio: "inherit"
+      });
+      await this.verifySignatures();
+      logger10.success("RAPID CLI updated successfully!");
+      logger10.info("Package published with npm provenance - cryptographically verified");
+      return true;
+    } catch (error) {
+      logger10.error("Failed to update RAPID CLI:", error);
+      return false;
+    }
+  }
+  /**
+   * Check for updates and handle them according to version type
+   */
+  async checkAndUpdate() {
+    if (!this.hasUpdate()) return;
+    const updateInfo = this.getUpdateInfo();
+    if (!updateInfo) return;
+    this.showNotification();
+    if (updateInfo.type === "major") {
+      logger10.warn(
+        `This is a major version update (${updateInfo.current} \u2192 ${updateInfo.latest}) that may contain breaking changes.`
+      );
+      try {
+        const response = await prompts({
+          type: "confirm",
+          name: "shouldUpdate",
+          message: "Would you like to update to this major version?",
+          initial: false
+        });
+        if (response.shouldUpdate) {
+          logger10.info(`Updating to ${updateInfo.latest} (major version)...`);
+          await this.performUpdate();
+        } else {
+          logger10.info("Skipping major version update.");
+          logger10.info('You can update later with "rapid update --force"');
+        }
+      } catch {
+        logger10.info(
+          'Run "rapid update" to update manually, or use "rapid update --force" to update automatically.'
+        );
+      }
+      return;
+    }
+    logger10.info(`Auto-updating to ${updateInfo.latest} (${updateInfo.type} version)...`);
+    await this.performUpdate();
+  }
+  /**
+   * Force update regardless of version type
+   */
+  async forceUpdate() {
+    if (!this.hasUpdate()) {
+      logger10.info("No updates available.");
+      return;
+    }
+    const updateInfo = this.getUpdateInfo();
+    if (updateInfo) {
+      this.showNotification();
+    }
+    await this.performUpdate();
+  }
+};
+var updateChecker = new UpdateChecker();
+
+// src/commands/update.ts
+import { logger as logger11 } from "@a3t/rapid-core";
+var updateCommand = new Command10("update").description("Check for and apply updates").option("--check", "Check for updates only").option("--force", "Force update even for major versions").action(async (options) => {
+  try {
+    if (options.check) {
+      logger11.header("Checking for updates...");
+      if (!updateChecker.hasUpdate()) {
+        logger11.success("You are using the latest version!");
+        return;
+      }
+      const updateInfo2 = updateChecker.getUpdateInfo();
+      if (updateInfo2) {
+        updateChecker.showNotification();
+        if (updateInfo2.type === "major") {
+          logger11.warn("This is a major version update with breaking changes.");
+          logger11.info('Use "rapid update --force" to update.');
+        } else {
+          logger11.info('Use "rapid update" to apply the update.');
+        }
+      }
+      return;
+    }
+    if (!updateChecker.hasUpdate()) {
+      logger11.success("You are already using the latest version!");
+      return;
+    }
+    const updateInfo = updateChecker.getUpdateInfo();
+    if (updateInfo && updateInfo.type === "major" && !options.force) {
+      logger11.warn("This is a major version update with breaking changes.");
+      logger11.info("Use --force to update anyway.");
+      return;
+    }
+    await updateChecker.forceUpdate();
+  } catch (error) {
+    logger11.error("Update failed:", error);
+    process.exit(1);
+  }
+});
+
+// src/commands/worktree.ts
+import { Command as Command11 } from "commander";
+import { logger as logger12 } from "@a3t/rapid-core";
+import ora9 from "ora";
+function formatWorktree(wt, currentPath) {
+  const isCurrent = wt.path === currentPath;
+  const marker = isCurrent ? logger12.brand("*") : " ";
+  const status = [];
+  if (wt.isMain) status.push("main");
+  if (wt.locked) status.push("locked");
+  if (wt.prunable) status.push("prunable");
+  if (!wt.exists) status.push("missing");
+  const statusStr = status.length > 0 ? logger12.dim(` (${status.join(", ")})`) : "";
+  const branchStr = wt.branch ? logger12.brand(wt.branch) : logger12.dim("detached");
+  const headShort = wt.head?.substring(0, 7) ?? "";
+  return `${marker} ${branchStr}${statusStr}
+    ${logger12.dim(wt.path)}
+    ${logger12.dim(`HEAD: ${headShort}`)}`;
+}
+var listCommand = new Command11("list").alias("ls").description("List all git worktrees").option("--json", "Output as JSON").action(async (options) => {
+  try {
+    const cwd = process.cwd();
+    if (!await isGitRepo(cwd)) {
+      logger12.error("Not a git repository");
+      process.exit(1);
+    }
+    const gitRoot = await getGitRoot(cwd);
+    const worktrees = await listWorktrees(gitRoot);
+    if (options.json) {
+      console.log(JSON.stringify(worktrees, null, 2));
+      return;
+    }
+    if (worktrees.length === 0) {
+      logger12.info("No worktrees found");
+      return;
+    }
+    logger12.header("Git Worktrees");
+    console.log();
+    for (const wt of worktrees) {
+      console.log(formatWorktree(wt, gitRoot));
+      console.log();
+    }
+    const prunable = worktrees.filter((wt) => wt.prunable);
+    if (prunable.length > 0) {
+      logger12.warn(`${prunable.length} worktree(s) can be pruned. Run: rapid worktree prune`);
+    }
+  } catch (error) {
+    logger12.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+var pruneCommand = new Command11("prune").description("Remove stale worktree references").option("--dry-run", "Show what would be pruned without removing").action(async (options) => {
+  const spinner = ora9("Checking worktrees...").start();
+  try {
+    const cwd = process.cwd();
+    if (!await isGitRepo(cwd)) {
+      spinner.fail("Not a git repository");
+      process.exit(1);
+    }
+    const gitRoot = await getGitRoot(cwd);
+    const worktrees = await listWorktrees(gitRoot);
+    const prunable = worktrees.filter((wt) => wt.prunable);
+    if (prunable.length === 0) {
+      spinner.succeed("No stale worktrees to prune");
+      return;
+    }
+    if (options.dryRun) {
+      spinner.info(`Would prune ${prunable.length} worktree(s):`);
+      for (const wt of prunable) {
+        console.log(`  ${logger12.dim("\u2022")} ${wt.path}`);
+      }
+      return;
+    }
+    spinner.text = `Pruning ${prunable.length} worktree(s)...`;
+    const result = await pruneWorktrees(gitRoot);
+    if (result.success) {
+      spinner.succeed(`Pruned ${result.pruned.length} worktree(s)`);
+      for (const path of result.pruned) {
+        console.log(`  ${logger12.dim("\u2022")} ${path}`);
+      }
+    } else {
+      spinner.fail(`Failed to prune: ${result.error}`);
+      process.exit(1);
+    }
+  } catch (error) {
+    spinner.fail(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+var removeCommand = new Command11("remove").alias("rm").description("Remove a worktree").argument("<path-or-branch>", "Worktree path or branch name").option("-f, --force", "Force removal even if worktree is dirty").action(async (pathOrBranch, options) => {
+  const spinner = ora9("Finding worktree...").start();
+  try {
+    const cwd = process.cwd();
+    if (!await isGitRepo(cwd)) {
+      spinner.fail("Not a git repository");
+      process.exit(1);
+    }
+    const gitRoot = await getGitRoot(cwd);
+    const worktrees = await listWorktrees(gitRoot);
+    const worktree = worktrees.find(
+      (wt) => wt.path === pathOrBranch || wt.path.endsWith(pathOrBranch) || wt.branch === pathOrBranch
+    );
+    if (!worktree) {
+      spinner.fail(`Worktree not found: ${pathOrBranch}`);
+      logger12.info("Available worktrees:");
+      for (const wt of worktrees) {
+        console.log(`  ${wt.branch || wt.path}`);
+      }
+      process.exit(1);
+    }
+    if (worktree.isMain) {
+      spinner.fail("Cannot remove the main worktree");
+      process.exit(1);
+    }
+    if (worktree.locked && !options.force) {
+      spinner.fail("Worktree is locked. Use --force to remove anyway.");
+      process.exit(1);
+    }
+    spinner.text = `Removing worktree: ${worktree.path}...`;
+    const result = await removeWorktree(gitRoot, worktree.path, { force: options.force });
+    if (result.success) {
+      spinner.succeed(`Removed worktree: ${worktree.path}`);
+    } else {
+      spinner.fail(`Failed to remove: ${result.error}`);
+      process.exit(1);
+    }
+  } catch (error) {
+    spinner.fail(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+var cleanupCommand = new Command11("cleanup").description("Remove worktrees for branches that have been merged").option("--dry-run", "Show what would be removed without removing").action(async (options) => {
+  const spinner = ora9("Analyzing worktrees...").start();
+  try {
+    const cwd = process.cwd();
+    if (!await isGitRepo(cwd)) {
+      spinner.fail("Not a git repository");
+      process.exit(1);
+    }
+    const gitRoot = await getGitRoot(cwd);
+    if (options.dryRun) {
+      const worktrees = await listWorktrees(gitRoot);
+      spinner.info("Dry run - would remove worktrees for merged branches");
+      const nonMain = worktrees.filter((wt) => !wt.isMain && wt.branch);
+      if (nonMain.length === 0) {
+        console.log("  No feature branch worktrees found");
+      } else {
+        console.log("  Feature branch worktrees:");
+        for (const wt of nonMain) {
+          console.log(`    ${logger12.dim("\u2022")} ${wt.branch} - ${wt.path}`);
+        }
+        console.log();
+        logger12.info("Run without --dry-run to remove worktrees for merged branches");
+      }
+      return;
+    }
+    spinner.text = "Removing worktrees for merged branches...";
+    const result = await cleanupMergedWorktrees(gitRoot);
+    if (result.removed.length === 0) {
+      spinner.succeed("No worktrees to clean up");
+      return;
+    }
+    spinner.succeed(`Cleaned up ${result.removed.length} worktree(s)`);
+    for (const path of result.removed) {
+      console.log(`  ${logger12.dim("\u2022")} ${path}`);
+    }
+    if (result.errors.length > 0) {
+      console.log();
+      logger12.warn("Some worktrees could not be removed:");
+      for (const err of result.errors) {
+        console.log(`  ${logger12.dim("\u2022")} ${err}`);
+      }
+    }
+  } catch (error) {
+    spinner.fail(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+var worktreeCommand = new Command11("worktree").alias("wt").description("Manage git worktrees for isolated development").addCommand(listCommand).addCommand(pruneCommand).addCommand(removeCommand).addCommand(cleanupCommand);
+worktreeCommand.action(async () => {
+  await listCommand.parseAsync([], { from: "user" });
+});
+
+// src/commands/lima.ts
+import { Command as Command12 } from "commander";
+import { logger as logger13 } from "@a3t/rapid-core";
+import ora10 from "ora";
+async function checkLimaAvailable() {
+  if (!isMacOS()) {
+    logger13.error("Lima is only available on macOS");
+    return false;
+  }
+  if (!await hasLima()) {
+    logger13.error("Lima is not installed");
+    logger13.blank();
+    logger13.info("Install Lima with:");
+    console.log(`  ${logger13.dim("$")} brew install lima`);
+    logger13.blank();
+    logger13.info("For more information: https://lima-vm.io");
+    return false;
+  }
+  return true;
+}
+var statusCommand2 = new Command12("status").description("Show Lima VM status").option("--json", "Output as JSON").action(async (options) => {
+  if (!await checkLimaAvailable()) {
+    process.exit(1);
+  }
+  const instance = await getInstance();
+  if (options.json) {
+    console.log(JSON.stringify(instance, null, 2));
+    return;
+  }
+  if (!instance) {
+    logger13.info(`Lima VM (${RAPID_LIMA_INSTANCE}) is not created`);
+    logger13.blank();
+    logger13.info("Start the VM with:");
+    console.log(`  ${logger13.dim("$")} rapid lima start`);
+    logger13.blank();
+    logger13.info("Or use:");
+    console.log(`  ${logger13.dim("$")} rapid dev --local`);
+    return;
+  }
+  logger13.header("Lima VM Status");
+  console.log();
+  console.log(`  ${logger13.dim("Name:")}     ${instance.name}`);
+  console.log(
+    `  ${logger13.dim("Status:")}   ${instance.status === "Running" ? logger13.brand(instance.status) : instance.status}`
+  );
+  console.log(`  ${logger13.dim("Arch:")}     ${instance.arch}`);
+  console.log(`  ${logger13.dim("CPUs:")}     ${instance.cpus}`);
+  console.log(`  ${logger13.dim("Memory:")}   ${instance.memory}`);
+  console.log(`  ${logger13.dim("Disk:")}     ${instance.disk}`);
+  if (instance.sshLocalPort) {
+    console.log(`  ${logger13.dim("SSH Port:")} ${instance.sshLocalPort}`);
+  }
+  console.log();
+  if (instance.status === "Running") {
+    logger13.info("To open a shell:");
+    console.log(`  ${logger13.dim("$")} rapid lima shell`);
+  } else {
+    logger13.info("To start the VM:");
+    console.log(`  ${logger13.dim("$")} rapid lima start`);
+  }
+  console.log();
+});
+var startCommand2 = new Command12("start").description("Start the Lima VM").option("--cpus <n>", "Number of CPUs", "4").option("--memory <size>", "Memory size", "8GiB").option("--disk <size>", "Disk size", "50GiB").action(async (options) => {
+  if (!await checkLimaAvailable()) {
+    process.exit(1);
+  }
+  const spinner = ora10("Starting Lima VM...").start();
+  const projectDir = process.cwd();
+  const result = await startInstance(projectDir, {
+    cpus: parseInt(options.cpus, 10),
+    memory: options.memory,
+    disk: options.disk,
+    timeout: 600
+  });
+  if (!result.success) {
+    spinner.fail("Failed to start Lima VM");
+    logger13.error(result.error ?? "Unknown error");
+    process.exit(1);
+  }
+  spinner.succeed("Lima VM started");
+  logger13.blank();
+  const sshSpinner = ora10("Checking SSH agent forwarding...").start();
+  const sshResult = await setupGitSsh();
+  if (sshResult.success) {
+    sshSpinner.succeed("SSH agent forwarding is working");
+  } else {
+    sshSpinner.warn("SSH agent forwarding may not be working");
+    logger13.dim(sshResult.error ?? "Make sure ssh-agent is running on the host");
+  }
+  logger13.blank();
+  logger13.info("To open a shell:");
+  console.log(`  ${logger13.dim("$")} rapid lima shell`);
+  console.log();
+});
+var stopCommand2 = new Command12("stop").description("Stop the Lima VM").option("-f, --force", "Force stop").action(async (options) => {
+  if (!await checkLimaAvailable()) {
+    process.exit(1);
+  }
+  const instance = await getInstance();
+  if (!instance) {
+    logger13.info("Lima VM is not created");
+    return;
+  }
+  if (instance.status !== "Running") {
+    logger13.info("Lima VM is already stopped");
+    return;
+  }
+  const spinner = ora10("Stopping Lima VM...").start();
+  const result = await stopInstance(RAPID_LIMA_INSTANCE, {
+    force: options.force
+  });
+  if (!result.success) {
+    spinner.fail("Failed to stop Lima VM");
+    logger13.error(result.error ?? "Unknown error");
+    process.exit(1);
+  }
+  spinner.succeed("Lima VM stopped");
+});
+var shellCommand = new Command12("shell").description("Open a shell in the Lima VM").option("-c, --command <cmd>", "Command to run instead of interactive shell").action(async (options) => {
+  if (!await checkLimaAvailable()) {
+    process.exit(1);
+  }
+  const instance = await getInstance();
+  if (!instance || instance.status !== "Running") {
+    logger13.error("Lima VM is not running");
+    logger13.info("Start with: rapid lima start");
+    process.exit(1);
+  }
+  await shellInLima({
+    cwd: process.cwd(),
+    command: options.command
+  });
+});
+var deleteCommand = new Command12("delete").description("Delete the Lima VM").option("-f, --force", "Force delete without confirmation").action(async (options) => {
+  if (!await checkLimaAvailable()) {
+    process.exit(1);
+  }
+  const instance = await getInstance();
+  if (!instance) {
+    logger13.info("Lima VM does not exist");
+    return;
+  }
+  if (!options.force) {
+    logger13.warn("This will permanently delete the Lima VM and all its data.");
+    logger13.info(`Use ${logger13.brand("--force")} to confirm deletion.`);
+    return;
+  }
+  const spinner = ora10("Deleting Lima VM...").start();
+  const result = await deleteInstance(RAPID_LIMA_INSTANCE, { force: true });
+  if (!result.success) {
+    spinner.fail("Failed to delete Lima VM");
+    logger13.error(result.error ?? "Unknown error");
+    process.exit(1);
+  }
+  spinner.succeed("Lima VM deleted");
+});
+var listCommand2 = new Command12("list").alias("ls").description("List all Lima instances").option("--json", "Output as JSON").action(async (options) => {
+  if (!await checkLimaAvailable()) {
+    process.exit(1);
+  }
+  const instances = await listInstances();
+  if (options.json) {
+    console.log(JSON.stringify(instances, null, 2));
+    return;
+  }
+  if (instances.length === 0) {
+    logger13.info("No Lima instances found");
+    return;
+  }
+  logger13.header("Lima Instances");
+  console.log();
+  for (const inst of instances) {
+    const isRapid = inst.name === RAPID_LIMA_INSTANCE;
+    const statusColor = inst.status === "Running" ? logger13.brand : logger13.dim;
+    console.log(
+      `  ${isRapid ? logger13.brand("*") : " "} ${inst.name} ${statusColor(`(${inst.status})`)}`
+    );
+    console.log(`    ${logger13.dim(`${inst.cpus} CPUs, ${inst.memory}, ${inst.disk}`)}`);
+  }
+  console.log();
+});
+var limaCommand = new Command12("lima").description("Manage Lima VM for local development (macOS)").addCommand(statusCommand2).addCommand(startCommand2).addCommand(stopCommand2).addCommand(shellCommand).addCommand(deleteCommand).addCommand(listCommand2);
+limaCommand.action(async () => {
+  await statusCommand2.parseAsync([], { from: "user" });
+});
+
 // src/index.ts
-var __dirname = dirname(fileURLToPath(import.meta.url));
-var packageJson = JSON.parse(readFileSync(join4(__dirname, "../package.json"), "utf-8"));
-var VERSION = packageJson.version;
-var program = new Command10();
-program.name("rapid").description("AI-assisted development with dev containers").version(VERSION, "-v, --version", "Show version").option("--verbose", "Verbose output").option("-q, --quiet", "Minimal output").option("--config <path>", "Path to rapid.json").hook("preAction", (thisCommand) => {
+var __dirname2 = dirname4(fileURLToPath3(import.meta.url));
+var packageJson2 = JSON.parse(readFileSync2(join7(__dirname2, "../package.json"), "utf-8"));
+var VERSION = packageJson2.version;
+var program = new Command13();
+program.name("rapid").description("AI-assisted development with dev containers").version(VERSION, "-v, --version", "Show version").option("--verbose", "Verbose output").option("-q, --quiet", "Minimal output").option("--config <path>", "Path to rapid.json").hook("preAction", async (thisCommand) => {
   const opts = thisCommand.opts();
   if (opts.verbose) {
     setLogLevel("debug");
   } else if (opts.quiet) {
     setLogLevel("error");
   }
+  if (thisCommand.name() === "update" || thisCommand.name() === "version") {
+    return;
+  }
+  try {
+    await updateChecker.checkAndUpdate();
+  } catch (error) {
+    logger14.debug("Update check failed:", error);
+  }
 });
 program.addCommand(initCommand);
 program.addCommand(startCommand);
@@ -2114,10 +3607,13 @@ program.addCommand(agentCommand);
 program.addCommand(secretsCommand);
 program.addCommand(authCommand);
 program.addCommand(mcpCommand);
+program.addCommand(updateCommand);
+program.addCommand(worktreeCommand);
+program.addCommand(limaCommand);
 program.action(() => {
   console.log();
-  console.log(`  ${logger10.brand("RAPID")} ${logger10.dim(`v${VERSION}`)}`);
-  console.log(`  ${logger10.dim("AI-assisted development with dev containers")}`);
+  console.log(`  ${logger14.brand("RAPID")} ${logger14.dim(`v${VERSION}`)}`);
+  console.log(`  ${logger14.dim("AI-assisted development with dev containers")}`);
   console.log();
   program.help();
 });
@@ -2125,4 +3621,4 @@ program.action(() => {
 export {
   program
 };
-//# sourceMappingURL=chunk-FICHP3SD.js.map
+//# sourceMappingURL=chunk-C6XSZWFT.js.map