brn-toolkit 1.0.0

package/dist/skills/jira/scripts/update_ticket.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env npx tsx
+/**
+ * Update JIRA ticket status via transition
+ * Usage: npx tsx update_ticket.ts <ticket_key> <target_status>
+ */
+import { jiraRequest } from "../../../lib/utils.js";
+const [ticketKey, targetStatus] = process.argv.slice(2);
+if (!ticketKey || !targetStatus) {
+    console.log("Usage: npx tsx update_ticket.ts <ticket_key> <target_status>");
+    console.log("Example: npx tsx update_ticket.ts PROJ-123 'In Progress'");
+    process.exit(1);
+}
+// Get available transitions
+const { transitions } = await jiraRequest(`/rest/api/3/issue/${ticketKey}/transitions`);
+// Find matching transition (case-insensitive)
+const transition = transitions.find((t) => t.name.toLowerCase() === targetStatus.toLowerCase());
+if (!transition) {
+    console.error(`Error: Transition '${targetStatus}' not available`);
+    console.error("Available transitions:");
+    for (const t of transitions) {
+        console.error(`  - ${t.name}`);
+    }
+    process.exit(1);
+}
+// Perform transition
+await jiraRequest(`/rest/api/3/issue/${ticketKey}/transitions`, {
+    method: "POST",
+    body: JSON.stringify({ transition: { id: transition.id } }),
+});
+console.log(`✓ Transitioned ${ticketKey} to '${targetStatus}'`);

package/dist/skills/workflow/scripts/start.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env npx tsx
+/**
+ * Initiate a new development workflow for a JIRA ticket
+ * Usage: npx tsx start.ts <ticket_id>
+ */
+import { $ } from "zx";
+import { getActiveWorkspace, jiraRequest } from "../../../lib/utils.js";
+import { join } from "path";
+import { homedir } from "os";
+$.verbose = false;
+const ticketId = process.argv[2];
+if (!ticketId) {
+    console.log("Usage: npx tsx start.ts <ticket_id>");
+    console.log("Example: npx tsx start.ts PROJ-123");
+    process.exit(1);
+}
+async function run() {
+    console.log(`🚀 Initiating workflow for ${ticketId}...`);
+    // 1. Fetch ticket details
+    console.log(`📋 Fetching ticket ${ticketId}...`);
+    const ticket = await jiraRequest(`/rest/api/3/issue/${ticketId}`);
+    const summary = ticket.fields.summary;
+    const projectKey = ticket.fields.project.key;
+    console.log(`✅ Ticket found: ${summary}`);
+    // 2. Identify repo (simple heuristic or prompt)
+    // For now, let's look for repos in the workspace
+    const workspace = getActiveWorkspace();
+    let workDir = workspace.path;
+    if (workDir.startsWith("~")) {
+        workDir = join(homedir(), workDir.slice(1));
+    }
+    // In a real scenario, we might have a mapping or ask the user
+    // For this automation, we'll try to find a repo that matches the project key or ask
+    console.log(`📂 Searching for repositories in ${workDir}...`);
+    // List directories in workDir
+    const repos = (await $ `ls -d ${workDir}/*/ 2>/dev/null`.quiet()).stdout
+        .split("\n")
+        .map(p => p.trim())
+        .filter(p => p && !p.endsWith("-worktrees/"))
+        .map(p => p.split("/").filter(Boolean).pop());
+    if (repos.length === 0) {
+        console.error("❌ No repositories found in workspace. Please clone a repo first using git-worktree:clone.");
+        process.exit(1);
+    }
+    let selectedRepo = repos[0];
+    if (repos.length > 1) {
+        console.log("Multiple repositories found:");
+        repos.forEach((r, i) => console.log(`  ${i + 1}. ${r}`));
+        console.log(`Using ${selectedRepo} (default). To use another, clone it or configure mapping.`);
+    }
+    // 3. Create branch name
+    const branchName = `${ticketId}-${summary.toLowerCase().replace(/[^a-z0-9]/g, "-").slice(0, 30)}`;
+    // 4. Create worktree
+    console.log(`🌿 Creating worktree for branch ${branchName}...`);
+    const createWorktreeScript = join(process.cwd(), "skills/git-worktree/scripts/create_worktree.sh");
+    await $ `${createWorktreeScript} ${selectedRepo} ${branchName}`;
+    // 5. Update ticket status
+    console.log(`🔄 Updating ticket status to 'In Progress'...`);
+    const updateTicketScript = join(process.cwd(), "skills/jira/scripts/update_ticket.ts");
+    await $ `npx tsx ${updateTicketScript} ${ticketId} "In Progress"`.quiet();
+    const worktreePath = join(workDir, `${selectedRepo}-worktrees`, branchName);
+    console.log("\n" + "=".repeat(50));
+    console.log(`✅ Workflow initiated successfully!`);
+    console.log(`📍 Worktree: ${worktreePath}`);
+    console.log(`🔗 Ticket: ${workspace.jira_url}/browse/${ticketId}`);
+    console.log("=".repeat(50));
+    console.log(`
+Next steps:
+  cd ${worktreePath}
+  # Start planning and coding!`);
+}
+run().catch(err => {
+    console.error("❌ Error initiating workflow:", err.message);
+    process.exit(1);
+});

package/dist/skills/workspace-manager/scripts/configure_workspace.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env npx tsx
+/**
+ * Configure a workspace setting
+ * Usage: npx tsx configure_workspace.ts <workspace_name> <key> <value>
+ */
+import { getBrnConfig, saveBrnConfig } from "../../../lib/utils.js";
+const workspaceName = process.argv[2];
+const key = process.argv[3];
+const value = process.argv[4];
+if (!workspaceName || !key || !value) {
+    console.log("Usage: configure_workspace.ts <workspace_name> <key> <value>");
+    console.log("");
+    console.log("Standard keys: github_token, jira_token, jira_url, jira_email, path");
+    console.log("");
+    console.log("Automation keys (default: false):");
+    console.log("  automation.github_auto_push      - Auto-push commits");
+    console.log("  automation.github_auto_pr        - Auto-create PRs");
+    console.log("  automation.jira_auto_transition  - Auto-update ticket status");
+    console.log("  automation.jira_auto_comment     - Auto-add comments");
+    process.exit(1);
+}
+const config = getBrnConfig();
+if (!config.workspaces[workspaceName]) {
+    console.error(`Error: Workspace '${workspaceName}' not found`);
+    process.exit(1);
+}
+// Validate key
+const validKeys = ["github_token", "github_org", "jira_token", "jira_url", "jira_email", "path"];
+const validAutomationKeys = [
+    "automation.github_auto_push",
+    "automation.github_auto_pr",
+    "automation.jira_auto_transition",
+    "automation.jira_auto_comment"
+];
+let isValid = validKeys.includes(key) || validAutomationKeys.includes(key);
+if (!isValid) {
+    console.error(`Error: Invalid key '${key}'`);
+    console.log(`Valid keys: ${validKeys.join(", ")}`);
+    console.log(`Automation keys: ${validAutomationKeys.join(", ")}`);
+    process.exit(1);
+}
+// Handle automation keys (nested)
+if (key.startsWith("automation.")) {
+    const automationKey = key.replace("automation.", "");
+    const boolValue = value === "true";
+    if (value !== "true" && value !== "false") {
+        console.error("Error: Automation values must be 'true' or 'false'");
+        process.exit(1);
+    }
+    if (!config.workspaces[workspaceName].automation) {
+        config.workspaces[workspaceName].automation = {};
+    }
+    config.workspaces[workspaceName].automation[automationKey] = boolValue;
+}
+else {
+    config.workspaces[workspaceName][key] = value;
+}
+saveBrnConfig(config);
+console.log(`✓ Set ${key} for workspace '${workspaceName}'`);

package/dist/skills/workspace-manager/scripts/create_workspace.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env npx tsx
+/**
+ * Create a new workspace
+ * Usage: npx tsx create_workspace.ts <name> <work_dir>
+ */
+import { existsSync, mkdirSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import YAML from "yaml";
+import { saveBrnConfig } from "../../../lib/utils.js";
+const workspaceName = process.argv[2];
+let workDir = process.argv[3];
+if (!workspaceName || !workDir) {
+    console.log("Usage: create_workspace.ts <name> <work_dir>");
+    console.log("Example: create_workspace.ts personal ~/dev/personal/auto");
+    process.exit(1);
+}
+const configPath = join(homedir(), ".brn", "config.yaml");
+const configDir = join(homedir(), ".brn");
+// Create config directory if it doesn't exist
+if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+}
+// Expand work_dir path
+if (workDir.startsWith("~")) {
+    workDir = join(homedir(), workDir.slice(1));
+}
+let config = {
+    version: "1.0",
+    active_workspace: workspaceName,
+    workspaces: {}
+};
+if (existsSync(configPath)) {
+    const content = readFileSync(configPath, "utf-8");
+    config = YAML.parse(content);
+}
+// Check if workspace already exists
+if (config.workspaces && config.workspaces[workspaceName]) {
+    console.error(`Error: Workspace '${workspaceName}' already exists`);
+    process.exit(1);
+}
+if (!config.workspaces) {
+    config.workspaces = {};
+}
+config.workspaces[workspaceName] = {
+    path: workDir,
+    github_token: null,
+    jira_token: null,
+    jira_url: null
+};
+// If no active workspace, set this one
+if (!config.active_workspace) {
+    config.active_workspace = workspaceName;
+}
+saveBrnConfig(config);
+// Create the work directory
+if (!existsSync(workDir)) {
+    mkdirSync(workDir, { recursive: true });
+}
+console.log(`✓ Created workspace '${workspaceName}' at ${workDir}`);

package/lib/utils.ts

@@ -0,0 +1,236 @@
+/**
+ * Shared utilities for brn scripts
+ */
+import { $ } from "zx";
+import { readFileSync, existsSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import YAML from "yaml";
+
+$.verbose = false;
+
+export interface AutomationConfig {
+    github_auto_push?: boolean;
+    github_auto_pr?: boolean;
+    jira_auto_transition?: boolean;
+    jira_auto_comment?: boolean;
+}
+
+export interface WorkspaceConfig {
+    path: string;
+    github_token?: string | null;
+    github_org?: string | null;
+    jira_token?: string | null;
+    jira_url?: string | null;
+    jira_email?: string | null;
+    automation?: AutomationConfig;
+}
+
+export interface BrnConfig {
+    version: string;
+    active_workspace: string;
+    workspaces: Record<string, WorkspaceConfig>;
+}
+
+/**
+ * Get the brn config from ~/.brn/config.yaml
+ */
+export function getBrnConfig(): BrnConfig {
+    const configPath = join(homedir(), ".brn", "config.yaml");
+
+    if (!existsSync(configPath)) {
+        console.error("Error: No config found at ~/.brn/config.yaml");
+        console.error("Run: create_workspace.sh <name> <path>");
+        process.exit(1);
+    }
+
+    const content = readFileSync(configPath, "utf-8");
+    return YAML.parse(content) as BrnConfig;
+}
+
+/**
+ * Save the brn config to ~/.brn/config.yaml
+ */
+export function saveBrnConfig(config: BrnConfig): void {
+    const configPath = join(homedir(), ".brn", "config.yaml");
+    writeFileSync(configPath, YAML.stringify(config));
+}
+
+/**
+ * Update the active workspace configuration
+ */
+export function updateWorkspace(updates: Partial<WorkspaceConfig>): void {
+    const config = getBrnConfig();
+    const activeWorkspaceName = config.active_workspace;
+    
+    if (!config.workspaces[activeWorkspaceName]) {
+        console.error(`Error: Active workspace '${activeWorkspaceName}' not found`);
+        process.exit(1);
+    }
+
+    config.workspaces[activeWorkspaceName] = {
+        ...config.workspaces[activeWorkspaceName],
+        ...updates,
+    };
+
+    saveBrnConfig(config);
+}
+
+/**
+ * Get the active workspace config
+ */
+export function getActiveWorkspace(): WorkspaceConfig & { name: string } {
+    const config = getBrnConfig();
+    const name = config.active_workspace;
+    const workspace = config.workspaces[name];
+
+    if (!workspace) {
+        console.error(`Error: Workspace '${name}' not found in config`);
+        process.exit(1);
+    }
+
+    return { name, ...workspace };
+}
+
+/**
+ * Check if an automation action is enabled for the active workspace.
+ * All automation is OFF by default for safety.
+ */
+export function isAutomationEnabled(
+    action: keyof AutomationConfig
+): boolean {
+    const workspace = getActiveWorkspace();
+    return workspace.automation?.[action] ?? false;
+}
+
+/**
+ * Require automation to be enabled, or prompt user to confirm.
+ * Returns true if action should proceed, false if user declined.
+ */
+export function checkAutomation(
+    action: keyof AutomationConfig,
+    description: string
+): boolean {
+    if (isAutomationEnabled(action)) {
+        return true;
+    }
+
+    console.log(`⚠️  Automation disabled: ${description}`);
+    console.log(`   To enable, run: configure_workspace.sh <workspace> automation.${action} true`);
+    console.log(`   Skipping automatic execution.`);
+    return false;
+}
+
+/**
+ * Get GitHub token from active workspace
+ */
+export function getGitHubToken(): string {
+    const workspace = getActiveWorkspace();
+
+    if (!workspace.github_token) {
+        console.error("Error: github_token not configured for this workspace");
+        console.error(
+            `Run: configure_workspace.sh ${workspace.name} github_token <token>`
+        );
+        process.exit(1);
+    }
+
+    return workspace.github_token;
+}
+
+/**
+ * Get JIRA config from active workspace
+ */
+export function getJiraConfig(): {
+    url: string;
+    email: string;
+    token: string;
+} {
+    const workspace = getActiveWorkspace();
+
+    if (!workspace.jira_url) {
+        console.error("Error: jira_url not configured");
+        process.exit(1);
+    }
+    if (!workspace.jira_email) {
+        console.error("Error: jira_email not configured");
+        process.exit(1);
+    }
+    if (!workspace.jira_token) {
+        console.error("Error: jira_token not configured");
+        process.exit(1);
+    }
+
+    return {
+        url: workspace.jira_url.replace(/\/$/, ""),
+        email: workspace.jira_email,
+        token: workspace.jira_token,
+    };
+}
+
+/**
+ * Make a GitHub API request
+ */
+export async function githubRequest<T>(
+    endpoint: string,
+    options: RequestInit = {}
+): Promise<T> {
+    const token = getGitHubToken();
+
+    console.log(`[GitHub API] Requesting: ${endpoint}`);
+
+    const response = await fetch(`https://api.github.com${endpoint}`, {
+        ...options,
+        headers: {
+            Authorization: `Bearer ${token}`,
+            Accept: "application/vnd.github+json",
+            "X-GitHub-Api-Version": "2022-11-28",
+            "Content-Type": "application/json",
+            ...options.headers,
+        },
+    });
+
+    if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        console.error(`Error: ${response.status} - ${response.statusText}`);
+        if (error.message) console.error(`  ${error.message}`);
+        process.exit(1);
+    }
+
+    return response.json() as Promise<T>;
+}
+
+/**
+ * Make a JIRA API request
+ */
+export async function jiraRequest<T>(
+    endpoint: string,
+    options: RequestInit = {}
+): Promise<T> {
+    const { url, email, token } = getJiraConfig();
+    const auth = Buffer.from(`${email}:${token}`).toString("base64");
+
+    const response = await fetch(`${url}${endpoint}`, {
+        ...options,
+        headers: {
+            Authorization: `Basic ${auth}`,
+            Accept: "application/json",
+            "Content-Type": "application/json",
+            ...options.headers,
+        },
+    });
+
+    if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        console.error(`Error: ${response.status} - ${response.statusText}`);
+        if (error.errorMessages) console.error(`  ${error.errorMessages}`);
+        process.exit(1);
+    }
+
+    // Handle 204 No Content
+    if (response.status === 204) {
+        return {} as T;
+    }
+
+    return response.json() as Promise<T>;
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "brn-toolkit",
+  "version": "1.0.0",
+  "description": "AI Developer Workflow Toolkit - Skills for Claude Code and Copilot CLI",
+  "type": "module",
+  "author": "zfael",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zfael/brn.git"
+  },
+  "keywords": [],
+  "bin": {
+    "brn": "./dist/cli/brn.js"
+  },
+  "files": [
+    "dist",
+    "skills",
+    "lib",
+    "cli",
+    "README.md",
+    "GEMINI.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "setup": "npx tsx cli/brn.ts setup",
+    "github:repos": "npx tsx skills/github/scripts/list_repos.ts",
+    "github:repo": "npx tsx skills/github/scripts/get_repo_info.ts",
+    "github:pr:create": "npx tsx skills/github/scripts/create_pr.ts",
+    "github:pr:list": "npx tsx skills/github/scripts/list_prs.ts",
+    "jira:tickets": "npx tsx skills/jira/scripts/list_tickets.ts",
+    "jira:ticket": "npx tsx skills/jira/scripts/get_ticket.ts",
+    "jira:update": "npx tsx skills/jira/scripts/update_ticket.ts",
+    "jira:comment": "npx tsx skills/jira/scripts/add_comment.ts"
+  },
+  "dependencies": {
+    "tsx": "^4.7.0",
+    "yaml": "^2.3.4",
+    "zx": "^8.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "typescript": "^5.3.0"
+  }
+}

package/skills/git-worktree/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: brn:git-worktree
+description: |
+  Manage git repositories using the worktree pattern.
+  This allows multiple branches to be checked out simultaneously in sibling directories.
+---
+
+# Git Worktree Manager
+
+## Description
+The git-worktree skill manages repositories using a specific directory structure optimized for multi-tasking. Instead of a single `.git` folder with one working directory, it uses a "bare" clone (or similar) and creates a separate directory for each branch/feature.
+
+## Available Scripts
+
+### `clone_repo`
+Clones a repository into the current workspace, setting it up for worktree usage. This creates a directory structure where the main repo is stored, and worktrees can be added alongside it.
+
+*   **Usage**: `brn git-worktree clone_repo <repo_url> [name]`
+*   **Arguments**:
+    *   `repo_url`: The URL of the git repository to clone.
+    *   `name` (optional): The name of the directory to create. Defaults to the repo name from the URL.
+*   **Example**: `brn git-worktree clone_repo https://github.com/myorg/api.git`
+
+### `create_worktree`
+Creates a new worktree for a specific branch. If the branch doesn't exist, it can be created from a base branch.
+
+*   **Usage**: `brn git-worktree create_worktree <repo_name> <branch_name> [base_branch]`
+*   **Arguments**:
+    *   `repo_name`: The name of the repository (must be already cloned via `clone_repo`).
+    *   `branch_name`: The name of the new branch and worktree directory.
+    *   `base_branch` (optional): The branch to split from. Defaults to `main` or `master`.
+*   **Example**: `brn git-worktree create_worktree api feature/login`
+
+### `list_worktrees`
+Lists all active worktrees for a repository.
+
+*   **Usage**: `brn git-worktree list_worktrees <repo_name>`
+*   **Arguments**:
+    *   `repo_name`: The name of the repository to list worktrees for.
+*   **Example**: `brn git-worktree list_worktrees api`
+
+### `remove_worktree`
+Removes a worktree and its directory. This cleans up the working directory and the git worktree entry.
+
+*   **Usage**: `brn git-worktree remove_worktree <repo_name> <branch_name>`
+*   **Arguments**:
+    *   `repo_name`: The name of the repository.
+    *   `branch_name`: The name of the worktree/branch to remove.
+*   **Example**: `brn git-worktree remove_worktree api feature/login`

package/skills/git-worktree/scripts/clone_repo.sh

@@ -0,0 +1,53 @@
+#!/bin/bash
+# Clone a repository to the active workspace
+# Usage: clone_repo.sh <repo_url> [name]
+
+set -e
+
+REPO_URL="$1"
+REPO_NAME="$2"
+
+if [ -z "$REPO_URL" ]; then
+    echo "Usage: clone_repo.sh <repo_url> [name]"
+    echo "Example: clone_repo.sh https://github.com/org/my-app.git"
+    exit 1
+fi
+
+# Get the script directory to find workspace-manager
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+WORKSPACE_SCRIPT="$SCRIPT_DIR/../../workspace-manager/scripts/get_active_workspace.sh"
+
+if [ ! -f "$WORKSPACE_SCRIPT" ]; then
+    echo "Error: workspace-manager skill not found"
+    exit 1
+fi
+
+# Get workspace config
+WORKSPACE_JSON=$("$WORKSPACE_SCRIPT" --json)
+WORK_DIR=$(echo "$WORKSPACE_JSON" | yq -r '.path')
+WORK_DIR="${WORK_DIR/#\~/$HOME}"
+
+# Derive repo name from URL if not provided
+if [ -z "$REPO_NAME" ]; then
+    REPO_NAME=$(basename "$REPO_URL" .git)
+fi
+
+REPO_PATH="$WORK_DIR/$REPO_NAME"
+
+if [ -d "$REPO_PATH" ]; then
+    echo "Repository already exists at $REPO_PATH"
+    exit 0
+fi
+
+# Create work directory if needed
+mkdir -p "$WORK_DIR"
+
+# Clone the repository
+echo "Cloning $REPO_URL to $REPO_PATH..."
+git clone "$REPO_URL" "$REPO_PATH"
+
+# Create worktrees directory
+mkdir -p "$WORK_DIR/${REPO_NAME}-worktrees"
+
+echo "✓ Cloned '$REPO_NAME' to $REPO_PATH"
+echo "  Worktrees will be created in: $WORK_DIR/${REPO_NAME}-worktrees/"

package/skills/git-worktree/scripts/create_worktree.sh

@@ -0,0 +1,66 @@
+#!/bin/bash
+# Create a new worktree for a branch
+# Usage: create_worktree.sh <repo_name> <branch_name> [base_branch]
+
+set -e
+
+REPO_NAME="$1"
+BRANCH_NAME="$2"
+BASE_BRANCH="${3:-main}"
+
+if [ -z "$REPO_NAME" ] || [ -z "$BRANCH_NAME" ]; then
+    echo "Usage: create_worktree.sh <repo_name> <branch_name> [base_branch]"
+    echo "Example: create_worktree.sh my-app PROJ-123-feature main"
+    exit 1
+fi
+
+# Get the script directory to find workspace-manager
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+WORKSPACE_SCRIPT="$SCRIPT_DIR/../../workspace-manager/scripts/get_active_workspace.sh"
+
+if [ ! -f "$WORKSPACE_SCRIPT" ]; then
+    echo "Error: workspace-manager skill not found"
+    exit 1
+fi
+
+# Get workspace config
+WORKSPACE_JSON=$("$WORKSPACE_SCRIPT" --json)
+WORK_DIR=$(echo "$WORKSPACE_JSON" | yq -r '.path')
+WORK_DIR="${WORK_DIR/#\~/$HOME}"
+
+REPO_PATH="$WORK_DIR/$REPO_NAME"
+WORKTREES_DIR="$WORK_DIR/${REPO_NAME}-worktrees"
+WORKTREE_PATH="$WORKTREES_DIR/$BRANCH_NAME"
+
+if [ ! -d "$REPO_PATH" ]; then
+    echo "Error: Repository not found at $REPO_PATH"
+    echo "Run clone_repo.sh first"
+    exit 1
+fi
+
+if [ -d "$WORKTREE_PATH" ]; then
+    echo "Worktree already exists at $WORKTREE_PATH"
+    exit 0
+fi
+
+# Ensure worktrees directory exists
+mkdir -p "$WORKTREES_DIR"
+
+# Go to the main repo
+cd "$REPO_PATH"
+
+# Fetch latest
+echo "Fetching latest from origin..."
+git fetch origin
+
+# Try to checkout existing remote branch, or create new one from base
+if git show-ref --verify --quiet "refs/remotes/origin/$BRANCH_NAME"; then
+    echo "Creating worktree from existing remote branch..."
+    git worktree add "$WORKTREE_PATH" "$BRANCH_NAME"
+else
+    echo "Creating new branch '$BRANCH_NAME' from '$BASE_BRANCH'..."
+    git worktree add -b "$BRANCH_NAME" "$WORKTREE_PATH" "origin/$BASE_BRANCH"
+fi
+
+echo "✓ Created worktree at $WORKTREE_PATH"
+echo "  cd $WORKTREE_PATH"