santree 0.0.1

package/README.md

@@ -0,0 +1,166 @@
+# Santree
+
+A beautiful CLI for managing Git worktrees with Linear and GitHub integration.
+
+Built with [React](https://react.dev/), [Ink](https://github.com/vadimdemedes/ink), and [Pastel](https://github.com/vadimdemedes/pastel).
+
+## Installation
+
+```bash
+npm install -g santree
+```
+
+## Requirements
+
+### Required
+
+| Tool | Version | Purpose | Installation |
+|------|---------|---------|--------------|
+| **Node.js** | >= 20 | Runtime | [nodejs.org](https://nodejs.org/) or `brew install node` |
+| **Git** | Any recent | Worktree operations | [git-scm.com](https://git-scm.com/) or `brew install git` |
+| **GitHub CLI** | Any recent | PR creation, status, cleanup | `brew install gh` then `gh auth login` |
+| **tmux** | Any recent | Create worktrees in new windows | `brew install tmux` |
+| **Claude Code** | Any recent | AI coding assistant | `npm install -g @anthropic-ai/claude-code` |
+| **Happy** | - | Claude CLI wrapper | Your custom wrapper around Claude Code |
+| **Linear MCP** | - | Linear ticket context | See below |
+
+### Setup
+
+#### GitHub CLI
+
+After installing, authenticate with GitHub:
+
+```bash
+brew install gh
+gh auth login
+```
+
+#### Happy (Claude Integration)
+
+The `santree work` command uses Happy to launch Claude with ticket context. Happy should be configured with the Linear MCP server to fetch ticket details.
+
+#### Linear MCP Server
+
+Add the Linear MCP server to your Claude configuration for ticket integration:
+
+```bash
+claude mcp add --transport http linear https://mcp.linear.app/mcp
+```
+
+This enables Claude to fetch Linear ticket details and comments when using `santree work`.
+
+## Features
+
+- **Worktree Management**: Create, switch, list, and remove Git worktrees
+- **Linear Integration**: Extract ticket IDs from branch names for Claude AI workflows
+- **GitHub Integration**: View PR status, create PRs, and clean up merged branches
+- **Claude AI Integration**: Launch Claude with context about your current ticket
+- **Beautiful UI**: Animated spinners, colored output, and box-styled layouts
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `santree list` | List all worktrees with status, PR info, and commits ahead |
+| `santree create <branch>` | Create a new worktree from base branch |
+| `santree switch <branch>` | Switch to another worktree |
+| `santree remove <branch>` | Remove a worktree and its branch |
+| `santree sync` | Sync current worktree with base branch (merge by default) |
+| `santree setup` | Run the init script (`.santree/init.sh`) |
+| `santree work` | Launch Claude to work on the current ticket |
+| `santree clean` | Remove worktrees with merged/closed PRs |
+
+## Options
+
+### create
+- `--base <branch>` - Base branch to create from (default: main/master)
+- `--work` - Launch Claude after creating
+- `--plan` - With --work, only create implementation plan
+- `--no-pull` - Skip pulling latest changes
+
+### sync
+- `--rebase` - Use rebase instead of merge
+
+### work
+- `--plan` - Only create implementation plan
+- `--review` - Review changes against ticket requirements
+- `--fix-pr` - Fetch PR comments and fix them
+
+### remove
+- `--force` - Force removal even with uncommitted changes
+
+### clean
+- `--dry-run` - Show what would be removed without removing
+- `--force` - Skip confirmation prompt
+
+## Setup
+
+### Init Script
+
+Create `.santree/init.sh` in your repository root to run custom setup when creating worktrees:
+
+```bash
+#!/bin/bash
+# Example: Copy .env, install dependencies, etc.
+cp "$SANTREE_REPO_ROOT/.env" "$SANTREE_WORKTREE_PATH/.env"
+npm install
+```
+
+Environment variables available:
+- `SANTREE_WORKTREE_PATH` - Path to the new worktree
+- `SANTREE_REPO_ROOT` - Path to the main repository
+
+### Branch Naming
+
+For Linear integration, use branch names with ticket IDs:
+
+```
+user/TEAM-123-feature-description
+feature/PROJ-456-add-auth
+```
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Build
+npm run build
+
+# Lint
+npm run lint
+
+# Run locally
+node dist/cli.js <command>
+```
+
+## CI/CD
+
+This project uses GitHub Actions for continuous integration and deployment.
+
+### Workflows
+
+- **CI** (`ci.yml`): Runs on every push and PR to `main`. Builds the project and runs linting.
+- **Release** (`release.yml`): Publishes to npm when a GitHub release is created.
+
+### Setting Up npm Publishing
+
+1. Generate an npm access token:
+   - Go to [npmjs.com](https://www.npmjs.com/) → Account → Access Tokens
+   - Create a new **Granular Access Token** with publish permissions
+
+2. Add the token to GitHub:
+   - Go to your repo → Settings → Secrets and variables → Actions
+   - Create a new secret named `NPM_TOKEN` with your token
+
+### Creating a Release
+
+1. Update the version in `package.json`
+2. Commit and push to `main`
+
+The workflow automatically detects version changes, publishes to npm, creates a git tag, and generates a GitHub release.
+
+## Shell Integration
+
+The shell wrapper in `alias.zsh` handles directory switching for `create` and `switch` commands, since child processes cannot change the parent shell's directory.

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import Pastel from "pastel";
+const app = new Pastel({
+    importMeta: import.meta,
+    name: "santree",
+    version: "1.0.0",
+    description: "Beautiful CLI for managing Git worktrees",
+});
+await app.run();

package/dist/commands/clean.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+export declare const options: z.ZodObject<{
+    "dry-run": z.ZodOptional<z.ZodBoolean>;
+    force: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type Props = {
+    options: z.infer<typeof options>;
+};
+export default function Clean({ options }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/commands/clean.js

@@ -0,0 +1,111 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Text, Box, useInput, useApp } from "ink";
+import Spinner from "ink-spinner";
+import { z } from "zod";
+import { findMainRepoRoot, listWorktrees, removeWorktree, isWorktreePath, } from "../lib/git.js";
+import { getPRInfoAsync } from "../lib/github.js";
+export const options = z.object({
+    "dry-run": z.boolean().optional().describe("Show what would be removed"),
+    force: z.boolean().optional().describe("Skip confirmation"),
+});
+export default function Clean({ options }) {
+    const { exit } = useApp();
+    const [status, setStatus] = useState("checking");
+    const [message, setMessage] = useState("Checking worktrees for merged/closed PRs...");
+    const [staleWorktrees, setStaleWorktrees] = useState([]);
+    const [failed, setFailed] = useState(0);
+    const [repoRoot, setRepoRoot] = useState(null);
+    // Handle confirmation input
+    useInput((input) => {
+        if (status !== "confirming")
+            return;
+        if (input === "y" || input === "Y") {
+            removeStaleWorktrees();
+        }
+        else if (input === "n" || input === "N" || input === "\x03") {
+            setStatus("cancelled");
+            setMessage("Cancelled");
+            setTimeout(() => exit(), 100);
+        }
+    });
+    async function removeStaleWorktrees() {
+        if (!repoRoot)
+            return;
+        setStatus("removing");
+        let removedCount = 0;
+        let failedCount = 0;
+        for (const wt of staleWorktrees) {
+            const result = await removeWorktree(wt.branch, repoRoot, true);
+            if (result.success) {
+                removedCount++;
+            }
+            else {
+                failedCount++;
+            }
+        }
+        setFailed(failedCount);
+        setStatus("done");
+        setMessage(failedCount > 0
+            ? `Removed ${removedCount} worktree(s), ${failedCount} failed`
+            : `Removed ${removedCount} worktree(s)`);
+        setTimeout(() => exit(), 100);
+    }
+    useEffect(() => {
+        async function run() {
+            // Small delay to allow spinner to render
+            await new Promise((r) => setTimeout(r, 100));
+            // Find main repo root
+            const mainRepo = findMainRepoRoot();
+            if (!mainRepo) {
+                setStatus("error");
+                setMessage("Not inside a git repository");
+                return;
+            }
+            setRepoRoot(mainRepo);
+            const worktrees = listWorktrees();
+            // Filter to only worktrees (not main repo) with branches
+            const candidates = worktrees.filter((wt) => isWorktreePath(wt.path) && wt.branch);
+            // Fetch PR info for all worktrees in parallel
+            const prInfoResults = await Promise.all(candidates.map((wt) => getPRInfoAsync(wt.branch)));
+            // Find worktrees with merged/closed PRs
+            const stale = [];
+            for (let i = 0; i < candidates.length; i++) {
+                const wt = candidates[i];
+                const prInfo = prInfoResults[i];
+                if (prInfo &&
+                    (prInfo.state === "MERGED" || prInfo.state === "CLOSED")) {
+                    stale.push({
+                        branch: wt.branch,
+                        path: wt.path,
+                        prNum: prInfo.number,
+                        prState: prInfo.state,
+                    });
+                }
+            }
+            setStaleWorktrees(stale);
+            if (stale.length === 0) {
+                setStatus("none-found");
+                setMessage("No stale worktrees found. All worktrees have open PRs or no PRs.");
+                setTimeout(() => exit(), 100);
+                return;
+            }
+            // Dry run - just show what would be removed
+            if (options["dry-run"]) {
+                setStatus("done");
+                setMessage("Dry run - no changes made");
+                setTimeout(() => exit(), 100);
+                return;
+            }
+            // Skip confirmation if force flag
+            if (options.force) {
+                await removeStaleWorktrees();
+                return;
+            }
+            setStatus("confirming");
+        }
+        run();
+    }, [options["dry-run"], options.force]);
+    const isLoading = status === "checking" || status === "removing";
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, width: "100%", children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "\uD83E\uDDF9 Clean" }), options["dry-run"] && _jsx(Text, { color: "yellow", children: " (dry run)" })] }), isLoading && (_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsxs(Text, { children: [" ", message] })] })), staleWorktrees.length > 0 && (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Text, { children: ["Found", " ", _jsx(Text, { color: "yellow", bold: true, children: staleWorktrees.length }), " ", "stale worktree(s):"] }), staleWorktrees.map((wt) => (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: wt.prState === "MERGED" ? "magenta" : "red", paddingX: 1, marginTop: 1, width: "100%", children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "branch:" }), _jsx(Text, { color: "cyan", bold: true, children: wt.branch })] }), _jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "PR:" }), _jsxs(Text, { children: ["#", wt.prNum] }), _jsx(Text, { backgroundColor: wt.prState === "MERGED" ? "magenta" : "red", color: "white", children: ` ${wt.prState.toLowerCase()} ` })] }), _jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "path:" }), _jsx(Text, { dimColor: true, children: wt.path })] })] }, wt.branch)))] })), status === "confirming" && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { bold: true, color: "yellow", children: ["Remove these worktrees? [y/N]:", " "] }) })), status === "none-found" && (_jsxs(Text, { color: "green", bold: true, children: ["\u2713 ", message] })), status === "done" && (_jsxs(Text, { color: failed > 0 ? "yellow" : "green", bold: true, children: ["\u2713 ", message] })), status === "cancelled" && _jsxs(Text, { color: "yellow", children: ["\u2717 ", message] }), status === "error" && (_jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", message] }))] }));
+}

package/dist/commands/commit.d.ts

@@ -0,0 +1 @@
+export default function Commit(): import("react/jsx-runtime").JSX.Element;

package/dist/commands/commit.js

@@ -0,0 +1,163 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Text, Box, useInput, useApp } from "ink";
+import TextInput from "ink-text-input";
+import Spinner from "ink-spinner";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { findRepoRoot, getCurrentBranch, extractTicketId, getGitStatus, getStagedDiffStat, hasStagedChanges, hasUnstagedChanges, } from "../lib/git.js";
+const execAsync = promisify(exec);
+export default function Commit() {
+    const { exit } = useApp();
+    const [status, setStatus] = useState("loading");
+    const [message, setMessage] = useState("");
+    const [branch, setBranch] = useState(null);
+    const [ticketId, setTicketId] = useState(null);
+    const [gitStatus, setGitStatus] = useState("");
+    const [diffStat, setDiffStat] = useState("");
+    const [repoRoot, setRepoRoot] = useState(null);
+    const [commitInput, setCommitInput] = useState("");
+    // Handle confirmation for staging
+    useInput((input, key) => {
+        if (status === "confirm-stage") {
+            if (input === "y" || input === "Y") {
+                stageAndContinue();
+            }
+            else if (input === "n" || input === "N" || key.escape) {
+                if (hasStagedChanges()) {
+                    setStatus("awaiting-message");
+                    const prefix = ticketId ? `[${ticketId}] ` : "";
+                    setCommitInput(prefix);
+                }
+                else {
+                    setStatus("no-changes");
+                    setMessage("No staged changes to commit");
+                    setTimeout(() => exit(), 100);
+                }
+            }
+        }
+    });
+    async function stageAndContinue() {
+        try {
+            await execAsync("git add -A", { cwd: repoRoot ?? undefined });
+            setGitStatus(getGitStatus());
+            setDiffStat(getStagedDiffStat());
+            setStatus("awaiting-message");
+            const prefix = ticketId ? `[${ticketId}] ` : "";
+            setCommitInput(prefix);
+        }
+        catch (e) {
+            setStatus("error");
+            setMessage(`Failed to stage changes: ${e}`);
+        }
+    }
+    async function handleCommitSubmit(value) {
+        const trimmed = value.trim();
+        if (!trimmed) {
+            setStatus("error");
+            setMessage("Empty commit message, cancelled");
+            setTimeout(() => exit(), 100);
+            return;
+        }
+        // Prepend ticket ID if not already present
+        const commitMessage = ticketId && !trimmed.includes(`[${ticketId}]`)
+            ? `[${ticketId}] ${trimmed}`
+            : trimmed;
+        setStatus("committing");
+        setMessage("Creating commit...");
+        try {
+            await execAsync(`git commit -m "${commitMessage.replace(/"/g, '\\"')}"`, {
+                cwd: repoRoot ?? undefined,
+            });
+        }
+        catch (e) {
+            setStatus("error");
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            setMessage(`Commit failed: ${errorMsg}`);
+            setTimeout(() => exit(), 100);
+            return;
+        }
+        setStatus("pushing");
+        setMessage("Pushing to origin...");
+        try {
+            await execAsync(`git push -u origin "${branch}"`, {
+                cwd: repoRoot ?? undefined,
+            });
+        }
+        catch (e) {
+            setStatus("error");
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            setMessage(`Push failed: ${errorMsg}`);
+            setTimeout(() => exit(), 100);
+            return;
+        }
+        setStatus("done");
+        setMessage("Committed and pushed successfully!");
+        setTimeout(() => exit(), 100);
+    }
+    useEffect(() => {
+        async function init() {
+            await new Promise((r) => setTimeout(r, 100));
+            const root = findRepoRoot();
+            if (!root) {
+                setStatus("error");
+                setMessage("Not inside a git repository");
+                return;
+            }
+            setRepoRoot(root);
+            const currentBranch = getCurrentBranch();
+            if (!currentBranch) {
+                setStatus("error");
+                setMessage("Could not determine current branch");
+                return;
+            }
+            setBranch(currentBranch);
+            const ticket = extractTicketId(currentBranch);
+            setTicketId(ticket);
+            const statusOutput = getGitStatus();
+            if (!statusOutput) {
+                setStatus("no-changes");
+                setMessage("No changes");
+                setTimeout(() => exit(), 100);
+                return;
+            }
+            setGitStatus(statusOutput);
+            const unstaged = hasUnstagedChanges();
+            const staged = hasStagedChanges();
+            if (unstaged) {
+                setStatus("confirm-stage");
+            }
+            else if (staged) {
+                setDiffStat(getStagedDiffStat());
+                setStatus("awaiting-message");
+                const prefix = ticket ? `[${ticket}] ` : "";
+                setCommitInput(prefix);
+            }
+            else {
+                setStatus("no-changes");
+                setMessage("No changes to commit");
+                setTimeout(() => exit(), 100);
+            }
+        }
+        init();
+    }, []);
+    const isLoading = status === "loading" || status === "committing" || status === "pushing";
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, width: "100%", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "cyan", children: "\uD83D\uDCBE Commit" }) }), _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: status === "error" ? "red" : status === "done" ? "green" : "blue", paddingX: 1, width: "100%", children: [branch && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "branch:" }), _jsx(Text, { color: "cyan", bold: true, children: branch })] })), ticketId && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "ticket:" }), _jsx(Text, { color: "blue", bold: true, children: ticketId })] }))] }), gitStatus && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, dimColor: true, children: "Changes:" }), _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, width: "100%", children: [gitStatus
+                                .split("\n")
+                                .slice(0, 10)
+                                .map((line, i) => {
+                                let color;
+                                if (line.startsWith("A ") ||
+                                    line.startsWith("M ") ||
+                                    line.startsWith("D ")) {
+                                    color = "green";
+                                }
+                                else if (line.startsWith("??")) {
+                                    color = "gray";
+                                }
+                                else if (line.startsWith(" M") || line.startsWith(" D")) {
+                                    color = "yellow";
+                                }
+                                return (_jsx(Text, { color: color, children: line }, i));
+                            }), gitStatus.split("\n").length > 10 && (_jsxs(Text, { dimColor: true, children: ["... and ", gitStatus.split("\n").length - 10, " more"] }))] })] })), diffStat && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, dimColor: true, children: "Staged:" }), _jsx(Box, { flexDirection: "column", borderStyle: "round", borderColor: "green", paddingX: 1, width: "100%", children: diffStat.split("\n").map((line, i) => (_jsx(Text, { dimColor: true, children: line }, i))) })] })), _jsxs(Box, { marginTop: 1, children: [isLoading && (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsxs(Text, { children: [" ", message || "Loading..."] })] })), status === "confirm-stage" && (_jsxs(Text, { color: "yellow", bold: true, children: ["Stage all changes? [y/N]:", " "] })), status === "awaiting-message" && (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", bold: true, children: "Commit message: " }), _jsx(TextInput, { value: commitInput, onChange: setCommitInput, onSubmit: handleCommitSubmit })] })), status === "done" && (_jsxs(Text, { color: "green", bold: true, children: ["\u2713 ", message] })), status === "no-changes" && _jsxs(Text, { dimColor: true, children: ["\u2713 ", message] }), status === "error" && (_jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", message] }))] })] }));
+}

package/dist/commands/create.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export declare const options: z.ZodObject<{
+    base: z.ZodOptional<z.ZodString>;
+    work: z.ZodOptional<z.ZodBoolean>;
+    plan: z.ZodOptional<z.ZodBoolean>;
+    "no-pull": z.ZodOptional<z.ZodBoolean>;
+    tmux: z.ZodOptional<z.ZodBoolean>;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const args: z.ZodTuple<[z.ZodOptional<z.ZodString>], null>;
+type Props = {
+    options: z.infer<typeof options>;
+    args: z.infer<typeof args>;
+};
+export default function Create({ options, args }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/commands/create.js

@@ -0,0 +1,181 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Text, Box } from "ink";
+import Spinner from "ink-spinner";
+import { z } from "zod";
+import { spawn } from "child_process";
+import * as fs from "fs";
+import { createWorktree, findMainRepoRoot, getDefaultBranch, pullLatest, hasInitScript, getInitScriptPath, extractTicketId, } from "../lib/git.js";
+import { execSync } from "child_process";
+export const options = z.object({
+    base: z.string().optional().describe("Base branch to create from"),
+    work: z.boolean().optional().describe("Launch Claude after creating"),
+    plan: z.boolean().optional().describe("With --work, only plan"),
+    "no-pull": z.boolean().optional().describe("Skip pulling latest changes"),
+    tmux: z.boolean().optional().describe("Create a new tmux window"),
+    name: z.string().optional().describe("Custom tmux window name"),
+});
+export const args = z.tuple([z.string().optional().describe("Branch name")]);
+function isInTmux() {
+    return !!process.env.TMUX;
+}
+function createTmuxWindow(name, path, runCommand) {
+    try {
+        execSync(`tmux new-window -n "${name}" -c "${path}"`, { stdio: "ignore" });
+        // If a command is provided, send it to the new window
+        if (runCommand) {
+            execSync(`tmux send-keys -t "${name}" "${runCommand}" Enter`, { stdio: "ignore" });
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getWindowName(branchName, customName) {
+    if (customName)
+        return customName;
+    // Try to extract ticket ID (e.g., "TEAM-123")
+    const ticketId = extractTicketId(branchName);
+    if (ticketId)
+        return ticketId;
+    // Fallback to last part of branch name
+    const parts = branchName.split("/");
+    return parts[parts.length - 1] ?? branchName;
+}
+export default function Create({ options, args }) {
+    const [branchName] = args;
+    const [status, setStatus] = useState("idle");
+    const [message, setMessage] = useState("");
+    const [worktreePath, setWorktreePath] = useState("");
+    const [baseBranch, setBaseBranch] = useState(null);
+    const [tmuxWindowName, setTmuxWindowName] = useState(null);
+    function finalize(path, branch) {
+        // Handle tmux window creation
+        if (options.tmux) {
+            if (!isInTmux()) {
+                setMessage("Worktree created, but not in tmux session");
+                setStatus("done");
+                console.log(`SANTREE_CD:${path}`);
+                return;
+            }
+            setStatus("tmux");
+            setMessage("Creating tmux window...");
+            const windowName = getWindowName(branch, options.name);
+            setTmuxWindowName(windowName);
+            // Build command to run in new window (if --work is set)
+            let runCommand;
+            if (options.work) {
+                runCommand = options.plan ? "st work --plan" : "st work";
+            }
+            if (!createTmuxWindow(windowName, path, runCommand)) {
+                setMessage("Worktree created, but failed to create tmux window");
+                setStatus("done");
+                console.log(`SANTREE_CD:${path}`);
+                return;
+            }
+            setStatus("done");
+            const workInfo = options.work ? (options.plan ? " + Claude (plan)" : " + Claude") : "";
+            setMessage(`Worktree and tmux window created!${workInfo}`);
+            // Don't output SANTREE_CD when tmux window is created - user is already in new window
+            return;
+        }
+        setStatus("done");
+        setMessage("Worktree created successfully!");
+        console.log(`SANTREE_CD:${path}`);
+        if (options.work) {
+            const mode = options.plan ? "plan" : "implement";
+            console.log(`SANTREE_WORK:${mode}`);
+        }
+    }
+    useEffect(() => {
+        async function run() {
+            // Small delay to allow spinner to render
+            await new Promise((r) => setTimeout(r, 100));
+            if (!branchName) {
+                setStatus("error");
+                setMessage("Branch name is required");
+                return;
+            }
+            const branch = branchName; // Capture for closures
+            const mainRepo = findMainRepoRoot();
+            if (!mainRepo) {
+                setStatus("error");
+                setMessage("Not inside a git repository");
+                return;
+            }
+            const base = options.base ?? getDefaultBranch();
+            setBaseBranch(base);
+            // Pull latest unless --no-pull
+            if (!options["no-pull"]) {
+                setStatus("pulling");
+                setMessage(`Fetching latest changes for ${base}...`);
+                const pullResult = pullLatest(base, mainRepo);
+                if (!pullResult.success) {
+                    // Just warn, continue anyway
+                    setMessage(`Warning: ${pullResult.message}`);
+                }
+            }
+            setStatus("creating");
+            setMessage(`Creating worktree from ${base}...`);
+            const result = await createWorktree(branch, base, mainRepo);
+            if (result.success && result.path) {
+                setWorktreePath(result.path);
+                // Run init script if it exists
+                if (hasInitScript(mainRepo)) {
+                    setStatus("init-script");
+                    setMessage("Running init script...");
+                    const initScript = getInitScriptPath(mainRepo);
+                    // Check if executable
+                    try {
+                        fs.accessSync(initScript, fs.constants.X_OK);
+                    }
+                    catch {
+                        setMessage("Warning: Init script exists but is not executable");
+                        finalize(result.path, branch);
+                        return;
+                    }
+                    const child = spawn(initScript, [], {
+                        cwd: result.path,
+                        stdio: "pipe",
+                        env: {
+                            ...process.env,
+                            SANTREE_WORKTREE_PATH: result.path,
+                            SANTREE_REPO_ROOT: mainRepo,
+                        },
+                    });
+                    // Capture output but don't display (to avoid conflicting with Ink)
+                    child.stdout?.on("data", () => { });
+                    child.stderr?.on("data", () => { });
+                    child.on("error", (err) => {
+                        setMessage(`Warning: Init script failed: ${err.message}`);
+                    });
+                    child.on("close", (code) => {
+                        if (code !== 0) {
+                            setMessage(`Warning: Init script exited with code ${code}`);
+                        }
+                        finalize(result.path, branch);
+                    });
+                }
+                else {
+                    finalize(result.path, branch);
+                }
+            }
+            else {
+                setStatus("error");
+                setMessage(result.error ?? "Unknown error");
+            }
+        }
+        run();
+    }, [
+        branchName,
+        options.base,
+        options.work,
+        options.plan,
+        options["no-pull"],
+        options.tmux,
+        options.name,
+    ]);
+    const isLoading = status === "pulling" || status === "creating" || status === "init-script" || status === "tmux";
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, width: "100%", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "cyan", children: "\uD83C\uDF31 Create Worktree" }) }), branchName && (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: status === "error" ? "red" : status === "done" ? "green" : "blue", paddingX: 1, width: "100%", children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "branch:" }), _jsx(Text, { color: "cyan", bold: true, children: branchName })] }), baseBranch && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "base:" }), _jsx(Text, { color: "blue", children: baseBranch })] })), options["no-pull"] && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "skip pull:" }), _jsx(Text, { color: "yellow", children: "yes" })] })), options.work && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "after:" }), _jsx(Text, { backgroundColor: "magenta", color: "white", children: options.plan ? " plan " : " work " })] })), options.tmux && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "tmux:" }), _jsx(Text, { backgroundColor: "green", color: "white", children: ` ${options.name || "auto"} ` })] }))] })), _jsxs(Box, { marginTop: 1, children: [isLoading && (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsxs(Text, { children: [" ", message] })] })), status === "done" && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "green", bold: true, children: ["\u2713 ", message] }), _jsxs(Text, { dimColor: true, children: [" ", worktreePath] }), tmuxWindowName && (_jsxs(Text, { dimColor: true, children: [" tmux window: ", tmuxWindowName] }))] })), status === "error" && (_jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", message] }))] })] }));
+}