santree 0.3.0 → 0.5.0

package/dist/commands/doctor.js

@@ -11,6 +11,9 @@ const require = createRequire(import.meta.url);
 const { version } = require("../../package.json");
 import { findMainRepoRoot, getSantreeDir, getInitScriptPath } from "../lib/git.js";
 import { getAuthStatus, getValidTokens } from "../lib/linear.js";
+import { getMultiplexer } from "../lib/multiplexer/index.js";
+import { resolveClaudeBinary } from "../lib/ai.js";
+import { CURRENT_VERSION, CLAUDE_CODE_PACKAGE, SANTREE_PACKAGE, getLatestVersionFor, isUpdateAvailable, detectPackageManager, getInstallCommandFor, } from "../lib/version.js";
 const execAsync = promisify(exec);
 export const description = "Check system requirements and integrations";
 /**
@@ -55,6 +58,106 @@ async function checkTool(name, description, required, versionCommand, hint) {
         path,
     };
 }
+/**
+ * Reports the active multiplexer (tmux/cmux/none) and verifies the underlying
+ * binary is reachable. Surfaces a hint when the configured multiplexer can't run.
+ */
+async function checkMultiplexer() {
+    const mux = getMultiplexer();
+    const explicit = process.env["SANTREE_MULTIPLEXER"]?.toLowerCase();
+    const description = `Multiplexer (active: ${mux.kind}${explicit ? `, SANTREE_MULTIPLEXER=${explicit}` : ""})`;
+    if (mux.kind === "none") {
+        return {
+            name: "multiplexer",
+            description,
+            required: false,
+            installed: false,
+            hint: "No multiplexer active. Set SANTREE_MULTIPLEXER=tmux (or cmux) and run inside one. Install: brew install tmux",
+        };
+    }
+    if (mux.kind === "tmux") {
+        const path = await getPath("tmux");
+        if (!path) {
+            return {
+                name: "tmux",
+                description,
+                required: false,
+                installed: false,
+                hint: "Install: brew install tmux",
+            };
+        }
+        const version = await tryExec("tmux -V");
+        return {
+            name: "tmux",
+            description,
+            required: false,
+            installed: true,
+            version: version || "unknown",
+            path,
+        };
+    }
+    // cmux
+    const path = await getPath("cmux");
+    if (!path) {
+        return {
+            name: "cmux",
+            description,
+            required: false,
+            installed: false,
+            hint: "Install cmux.app from https://cmux.com or set SANTREE_MULTIPLEXER=tmux. cmux is macOS-only.",
+        };
+    }
+    const version = await tryExec("cmux --version 2>/dev/null");
+    const ping = await tryExec("cmux ping 2>/dev/null");
+    // Note: cmux #1472 (programmatic workspaces with dead PTYs) is a real
+    // limitation but only surfaces when a specific dashboard flow tries to
+    // auto-execute a command in a freshly-created workspace. Showing it on
+    // every doctor run made cmux look broken when it isn't — the limitation
+    // is documented in CLAUDE.md and the README. We only flag a hint here
+    // when cmux is actually unreachable.
+    return {
+        name: "cmux",
+        description,
+        required: false,
+        installed: !!ping,
+        version: version || "unknown",
+        path,
+        hint: !ping
+            ? "cmux app not reachable — open cmux.app or set SANTREE_MULTIPLEXER=tmux."
+            : undefined,
+    };
+}
+/**
+ * Checks the Claude CLI, preferring cmux's bundled binary when running inside
+ * cmux. The standard `checkTool` uses `which claude` which can't locate the
+ * cmux shim at /Applications/cmux.app/Contents/Resources/bin/claude — that
+ * binary isn't on PATH. See manaflow-ai/cmux#2048.
+ */
+async function checkClaude() {
+    const resolved = resolveClaudeBinary();
+    const inCmux = getMultiplexer().kind === "cmux";
+    const description = inCmux ? "Claude Code CLI (cmux-bundled)" : "Claude Code CLI";
+    if (!resolved) {
+        return {
+            name: "claude",
+            description,
+            required: true,
+            installed: false,
+            hint: inCmux
+                ? "Open cmux.app to install its bundled Claude, or install standalone: npm install -g @anthropic-ai/claude-code"
+                : "Install: npm install -g @anthropic-ai/claude-code",
+        };
+    }
+    const version = await tryExec(`"${resolved}" --version 2>/dev/null | head -1`);
+    return {
+        name: "claude",
+        description,
+        required: true,
+        installed: true,
+        version: version || "unknown",
+        path: resolved,
+    };
+}
 /**
  * Checks GitHub CLI auth status.
  * Uses `gh api user` which works across all gh versions.
@@ -346,7 +449,7 @@ function StatusIcon({ ok, required }) {
     return required ? _jsx(Text, { color: "red", children: "\u2717" }) : _jsx(Text, { color: "yellow", children: "\u25CB" });
 }
 function ToolRow({ tool }) {
-    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { children: [_jsx(StatusIcon, { ok: tool.installed && !tool.hint, required: tool.required }), _jsx(Text, { children: " " }), _jsx(Text, { bold: true, children: tool.name }), _jsxs(Text, { dimColor: true, children: [" - ", tool.description] }), !tool.required && _jsx(Text, { dimColor: true, children: " (optional)" })] }), tool.installed ? (_jsxs(Box, { marginLeft: 2, flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: ["Version: ", tool.version] }), _jsxs(Text, { dimColor: true, children: ["Path: ", tool.path] }), tool.authStatus && _jsxs(Text, { dimColor: true, children: ["Auth: ", tool.authStatus] }), tool.hint && _jsxs(Text, { color: "yellow", children: ["\u21B3 ", tool.hint] })] })) : (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: "yellow", children: ["\u21B3 ", tool.hint] }) }))] }));
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { children: [_jsx(StatusIcon, { ok: tool.installed && !tool.hint, required: tool.required }), _jsx(Text, { children: " " }), _jsx(Text, { bold: true, children: tool.name }), _jsxs(Text, { dimColor: true, children: [" - ", tool.description] }), !tool.required && _jsx(Text, { dimColor: true, children: " (optional)" })] }), tool.installed ? (_jsxs(Box, { marginLeft: 2, flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: ["Version: ", tool.version] }), tool.latestVersion && tool.version && (_jsxs(Text, { color: isUpdateAvailable(tool.version, tool.latestVersion) ? "yellow" : undefined, dimColor: !isUpdateAvailable(tool.version, tool.latestVersion), children: ["Latest: ", tool.latestVersion, isUpdateAvailable(tool.version, tool.latestVersion) ? " ⬆ update available" : ""] })), tool.path && _jsxs(Text, { dimColor: true, children: ["Path: ", tool.path] }), tool.authStatus && _jsxs(Text, { dimColor: true, children: ["Auth: ", tool.authStatus] }), tool.updateHint && _jsxs(Text, { color: "yellow", children: ["\u21B3 ", tool.updateHint] }), tool.hint && _jsxs(Text, { color: "yellow", children: ["\u21B3 ", tool.hint] })] })) : (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: "yellow", children: ["\u21B3 ", tool.hint] }) }))] }));
 }
 function LinearRow({ linear }) {
     const isOk = linear.authenticated && linear.tokenValid && linear.repoLinked;
@@ -396,30 +499,78 @@ export default function Doctor() {
     const [loading, setLoading] = useState(true);
     useEffect(() => {
         async function runChecks() {
-            const results = await Promise.all([
-                checkTool("git", "Version control", true, "git --version | head -1", "Install: brew install git"),
-                checkGhAuth(),
-                checkTool("tmux", "Terminal multiplexer", false, "tmux -V", "Install: brew install tmux"),
-                checkTool("claude", "Claude Code CLI", true, "claude --version 2>/dev/null | head -1", "Install: npm install -g @anthropic-ai/claude-code"),
+            const pm = detectPackageManager();
+            const [results, latestSantree, latestClaude] = await Promise.all([
+                Promise.all([
+                    checkTool("git", "Version control", true, "git --version | head -1", "Install: brew install git"),
+                    checkGhAuth(),
+                    checkMultiplexer(),
+                    checkClaude(),
+                ]),
+                getLatestVersionFor(SANTREE_PACKAGE),
+                getLatestVersionFor(CLAUDE_CODE_PACKAGE),
             ]);
-            // Check for either code or cursor (only need one)
+            // Synthetic row for santree itself — surfaces update status.
+            const santreeRow = {
+                name: "santree",
+                description: "Santree CLI (this app)",
+                required: true,
+                installed: true,
+                version: CURRENT_VERSION,
+                latestVersion: latestSantree ?? undefined,
+                updateHint: latestSantree && isUpdateAvailable(CURRENT_VERSION, latestSantree)
+                    ? "Run: santree update"
+                    : undefined,
+            };
+            results.unshift(santreeRow);
+            // Augment the claude row with latest-version info from npm registry.
+            // When the resolved binary is the cmux-bundled one, npm install can't
+            // update it — the bundled binary is shipped inside cmux.app. Show a
+            // cmux-aware hint instead of the generic npm command.
+            const claudeRow = results.find((r) => r.name === "claude");
+            if (claudeRow && claudeRow.installed && latestClaude) {
+                claudeRow.latestVersion = latestClaude;
+                if (claudeRow.version && isUpdateAvailable(claudeRow.version, latestClaude)) {
+                    const isCmuxBundled = !!claudeRow.path?.includes("/cmux.app/");
+                    if (isCmuxBundled) {
+                        claudeRow.updateHint = "Bundled with cmux — update cmux.app to get the latest Claude.";
+                    }
+                    else {
+                        const cmd = getInstallCommandFor(pm, `${CLAUDE_CODE_PACKAGE}@latest`);
+                        claudeRow.updateHint = `Run: ${cmd.display}`;
+                    }
+                }
+            }
+            // Optional: a syntax-highlighted diff pager — used by `st worktree diff`
+            // and the dashboard `v` overlay when SANTREE_DIFF_TOOL is set. Any
+            // pager works (delta, diff-so-fancy, …); without one set, git's
+            // default pager runs. Delta is the most popular choice so we check
+            // for it as a convenience, but it is never a hard dependency.
+            const deltaCheck = await checkTool("delta", "Recommended diff pager — any pager works", false, "delta --version | head -1", "Optional — git's default pager works too. Set SANTREE_DIFF_TOOL or `git config core.pager <tool>`. To install delta: brew install git-delta");
+            results.push(deltaCheck);
+            // Optional: a `.code-workspace`-aware editor (VSCode or Cursor).
+            // Santree itself works with any editor via $SANTREE_EDITOR — this
+            // check exists only because the dashboard's `E workspace` shortcut
+            // needs an editor that understands `.code-workspace` files. Missing
+            // here just means the shortcut is hidden; everything else still works.
+            const workspaceEditorDesc = "Workspace editor (`E workspace` shortcut)";
             const [codeCheck, cursorCheck] = await Promise.all([
-                checkTool("code", "VSCode editor", false, "code --version | head -1", ""),
-                checkTool("cursor", "Cursor editor", false, "cursor --version | head -1", ""),
+                checkTool("code", workspaceEditorDesc, false, "code --version | head -1", ""),
+                checkTool("cursor", workspaceEditorDesc, false, "cursor --version | head -1", ""),
             ]);
             if (codeCheck.installed) {
-                results.push({ ...codeCheck, description: "Editor (VSCode)" });
+                results.push(codeCheck);
             }
             else if (cursorCheck.installed) {
-                results.push({ ...cursorCheck, description: "Editor (Cursor)" });
+                results.push(cursorCheck);
             }
             else {
                 results.push({
                     name: "code/cursor",
-                    description: "Editor (VSCode or Cursor)",
+                    description: workspaceEditorDesc,
                     required: false,
                     installed: false,
-                    hint: "Install VSCode (https://code.visualstudio.com) or Cursor (https://cursor.sh)",
+                    hint: "Optional — santree works with any $SANTREE_EDITOR. Only needed for the dashboard's `.code-workspace` shortcut.",
                 });
             }
             const linearResult = await checkLinearAuth();

package/dist/commands/helpers/statusline.js

@@ -132,9 +132,17 @@ function getGitChanges(cwd) {
         untracked: countLines(git(cwd, "ls-files --others --exclude-standard")),
     };
 }
-// Build a progress bar for context usage
+// Build a progress bar for context usage.
+//
+// We deliberately inflate the displayed percentage by 20% (clamped to 100) so
+// the bar fills up faster than the model's actual context window. The point is
+// to nudge toward more-frequent /compact: the color thresholds (60%/80%) trip
+// earlier, so the yellow/red warnings show up while there's still real headroom
+// left to compact gracefully instead of after the model has already started
+// dropping content.
+const CONTEXT_DISPLAY_MULTIPLIER = 1.2;
 function formatContextUsage(usedPercentage) {
-    const used = Math.round(usedPercentage);
+    const used = Math.min(100, Math.round(usedPercentage * CONTEXT_DISPLAY_MULTIPLIER));
     const color = used >= 80 ? c.red : used >= 60 ? c.yellow : c.green;
     const width = 20;
     const filled = Math.round((used * width) / 100);

package/dist/commands/helpers/text-editor.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod/v4";
+export declare const description = "Open $EDITOR on a temp file, then print the path on stdout (compose with --context-file).";
+export declare const options: z.ZodObject<{
+    initial: z.ZodOptional<z.ZodString>;
+    from: z.ZodOptional<z.ZodString>;
+    ext: z.ZodDefault<z.ZodString>;
+    editor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type Props = {
+    options: z.infer<typeof options>;
+};
+export default function TextEditor({ options: opts }: Props): null;
+export {};

package/dist/commands/helpers/text-editor.js

@@ -0,0 +1,118 @@
+import { useEffect, useRef } from "react";
+import { useApp } from "ink";
+import { option } from "pastel";
+import { z } from "zod/v4";
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+export const description = "Open $EDITOR on a temp file, then print the path on stdout (compose with --context-file).";
+export const options = z.object({
+    initial: z
+        .string()
+        .optional()
+        .describe(option({ description: "Pre-fill the editor buffer with this text" })),
+    from: z
+        .string()
+        .optional()
+        .describe(option({ description: "Pre-fill the editor buffer with the contents of this file" })),
+    ext: z
+        .string()
+        .default("md")
+        .describe(option({ description: "Temp file extension (default: md)" })),
+    editor: z
+        .string()
+        .optional()
+        .describe(option({ description: "Override the editor command (default: $VISUAL || $EDITOR || vim)" })),
+});
+function resolveEditor(override) {
+    const raw = override ?? process.env["VISUAL"] ?? process.env["EDITOR"] ?? "vim";
+    const parts = raw.split(/\s+/).filter(Boolean);
+    const cmd = parts[0] ?? "vim";
+    return { cmd, args: parts.slice(1) };
+}
+// Render null and write all UI feedback to stderr so stdout stays clean for
+// shell capture: `file=$(st helpers text-editor) && st worktree work --context-file "$file"`.
+export default function TextEditor({ options: opts }) {
+    const { exit } = useApp();
+    const hasRun = useRef(false);
+    useEffect(() => {
+        if (hasRun.current)
+            return;
+        hasRun.current = true;
+        const ext = opts.ext.replace(/^\./, "");
+        const filePath = path.join(os.tmpdir(), `santree-edit-${Date.now()}.${ext}`);
+        const seed = (() => {
+            if (opts.from) {
+                try {
+                    return fs.readFileSync(opts.from, "utf-8");
+                }
+                catch {
+                    return opts.initial ?? "";
+                }
+            }
+            return opts.initial ?? "";
+        })();
+        try {
+            fs.writeFileSync(filePath, seed);
+        }
+        catch (err) {
+            process.stderr.write(`Failed to create temp file: ${err.message}\n`);
+            process.exitCode = 1;
+            exit();
+            return;
+        }
+        // Ink put stdin in raw mode on mount; release it for the editor.
+        const wasRaw = process.stdin.isTTY ? process.stdin.isRaw : false;
+        if (process.stdin.isTTY && process.stdin.setRawMode) {
+            try {
+                process.stdin.setRawMode(false);
+            }
+            catch { }
+        }
+        const { cmd, args } = resolveEditor(opts.editor);
+        const result = spawnSync(cmd, [...args, filePath], { stdio: "inherit" });
+        if (process.stdin.isTTY && process.stdin.setRawMode) {
+            try {
+                process.stdin.setRawMode(wasRaw);
+            }
+            catch { }
+        }
+        if (result.error || result.status !== 0) {
+            process.stderr.write(result.error
+                ? `Failed to launch editor '${cmd}': ${result.error.message}\n`
+                : `Editor '${cmd}' exited with status ${result.status}\n`);
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { }
+            process.exitCode = 1;
+            exit();
+            return;
+        }
+        let content = "";
+        try {
+            content = fs.readFileSync(filePath, "utf-8");
+        }
+        catch (err) {
+            process.stderr.write(`Failed to read temp file: ${err.message}\n`);
+            process.exitCode = 1;
+            exit();
+            return;
+        }
+        // Empty buffer => treat as cancel (matches `git commit` behavior)
+        if (content.trim().length === 0) {
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { }
+            process.stderr.write("Cancelled (empty buffer)\n");
+            process.exitCode = 1;
+            exit();
+            return;
+        }
+        process.stdout.write(`${filePath}\n`);
+        exit();
+    }, [opts, exit]);
+    return null;
+}

package/dist/commands/update.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export declare const description = "Update santree to the latest version on npm";
+export declare const options: z.ZodObject<{
+    force: z.ZodOptional<z.ZodBoolean>;
+    pm: z.ZodOptional<z.ZodEnum<{
+        npm: "npm";
+        pnpm: "pnpm";
+        yarn: "yarn";
+    }>>;
+}, z.core.$strip>;
+type Props = {
+    options: z.infer<typeof options>;
+};
+export default function Update({ options }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/commands/update.js

@@ -0,0 +1,72 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Text, Box, useApp } from "ink";
+import Spinner from "ink-spinner";
+import { z } from "zod";
+import { CURRENT_VERSION, CLAUDE_CODE_PACKAGE, getLatestVersion, getLatestVersionFor, getInstalledClaudeVersion, isUpdateAvailable, detectPackageManager, getInstallCommand, getInstallCommandFor, } from "../lib/version.js";
+import { spawnAsync } from "../lib/exec.js";
+export const description = "Update santree to the latest version on npm";
+export const options = z.object({
+    force: z.boolean().optional().describe("Reinstall even if already on the latest version"),
+    pm: z
+        .enum(["npm", "pnpm", "yarn"])
+        .optional()
+        .describe("Override package manager auto-detection"),
+});
+const TAIL_LINES = 8;
+function tail(text, n) {
+    return text
+        .split("\n")
+        .filter((l) => l.length > 0)
+        .slice(-n);
+}
+export default function Update({ options }) {
+    const { exit } = useApp();
+    const [status, setStatus] = useState("checking");
+    const [latest, setLatest] = useState(null);
+    const [pm, setPm] = useState("npm");
+    const [installCmd, setInstallCmd] = useState("");
+    const [output, setOutput] = useState("");
+    const [error, setError] = useState(null);
+    const [claude, setClaude] = useState(null);
+    useEffect(() => {
+        (async () => {
+            await new Promise((r) => setTimeout(r, 80));
+            // Check santree + claude versions in parallel.
+            const [latestVersion, latestClaude] = await Promise.all([
+                getLatestVersion({ force: true }),
+                getLatestVersionFor(CLAUDE_CODE_PACKAGE, { force: true }),
+            ]);
+            setLatest(latestVersion);
+            setClaude({ installed: getInstalledClaudeVersion(), latest: latestClaude });
+            const detectedPm = options.pm ?? detectPackageManager();
+            setPm(detectedPm);
+            const cmd = getInstallCommand(detectedPm);
+            setInstallCmd(cmd.display);
+            if (!latestVersion) {
+                setStatus("error");
+                setError("Could not reach the npm registry. Check your connection.");
+                setTimeout(() => exit(), 100);
+                return;
+            }
+            if (!options.force && !isUpdateAvailable(CURRENT_VERSION, latestVersion)) {
+                setStatus("up-to-date");
+                setTimeout(() => exit(), 100);
+                return;
+            }
+            setStatus("installing");
+            const result = await spawnAsync(cmd.cmd, cmd.args, {
+                onOutput: (data) => setOutput(data),
+            });
+            if (result.code === 0) {
+                setStatus("done");
+            }
+            else {
+                setStatus("error");
+                setError(`${cmd.display} exited with code ${result.code}`);
+            }
+            setTimeout(() => exit(), 100);
+        })();
+    }, []);
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "cyan", children: "Santree Update" }) }), _jsxs(Box, { flexDirection: "column", gap: 0, children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "current:" }), _jsxs(Text, { children: ["v", CURRENT_VERSION] })] }), latest && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "latest: " }), _jsxs(Text, { color: isUpdateAvailable(CURRENT_VERSION, latest) ? "yellow" : "green", children: ["v", latest] })] })), installCmd && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "via: " }), _jsxs(Text, { children: [installCmd, " ", _jsxs(Text, { dimColor: true, children: ["(detected: ", pm, ")"] })] })] }))] }), _jsxs(Box, { marginTop: 1, children: [status === "checking" && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { children: "Checking npm registry..." })] })), status === "installing" && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsxs(Text, { children: ["Running ", installCmd, "..."] })] })), status === "up-to-date" && (_jsx(Text, { color: "green", bold: true, children: "\u2713 Already on the latest version" })), status === "done" && latest && (_jsxs(Text, { color: "green", bold: true, children: ["\u2713 Updated to v", latest] })), status === "error" && error && (_jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", error] }))] }), (status === "installing" || status === "error") && output && (_jsx(Box, { marginTop: 1, flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, children: tail(output, TAIL_LINES).map((line, i) => (_jsx(Text, { dimColor: true, children: line }, i))) })), claude && claude.installed && (_jsx(Box, { marginTop: 1, flexDirection: "column", children: claude.latest && isUpdateAvailable(claude.installed, claude.latest) ? (_jsxs(_Fragment, { children: [_jsxs(Text, { color: "yellow", children: ["\u2B06 Claude Code ", claude.installed, " \u2192 ", claude.latest, " available"] }), _jsxs(Text, { dimColor: true, children: ["Run: ", getInstallCommandFor(pm, `${CLAUDE_CODE_PACKAGE}@latest`).display] })] })) : claude.latest ? (_jsxs(Text, { dimColor: true, children: ["\u2713 Claude Code ", claude.installed, " is up to date"] })) : null }))] }));
+}

package/dist/commands/worktree/create.d.ts

@@ -5,6 +5,7 @@ export declare const options: z.ZodObject<{
     work: z.ZodOptional<z.ZodBoolean>;
     plan: z.ZodOptional<z.ZodBoolean>;
     "no-pull": z.ZodOptional<z.ZodBoolean>;
+    window: z.ZodOptional<z.ZodBoolean>;
     tmux: z.ZodOptional<z.ZodBoolean>;
     name: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;

package/dist/commands/worktree/create.js

@@ -3,36 +3,21 @@ import { useEffect, useState } from "react";
 import { Text, Box } from "ink";
 import Spinner from "ink-spinner";
 import { z } from "zod";
-import { execSync } from "child_process";
 import * as fs from "fs";
 import { createWorktree, findMainRepoRoot, getDefaultBranch, pullLatest, hasInitScript, getInitScriptPath, extractTicketId, } from "../../lib/git.js";
 import { spawnAsync } from "../../lib/exec.js";
+import { getMultiplexer } from "../../lib/multiplexer/index.js";
 export const description = "Create a new worktree from a branch";
 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"),
+    window: z.boolean().optional().describe("Create a new multiplexer window/workspace (tmux/cmux)"),
+    tmux: z.boolean().optional().describe("Alias for --window (deprecated)"),
+    name: z.string().optional().describe("Custom window/workspace 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;
@@ -50,35 +35,38 @@ export default function Create({ options, args }) {
     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");
+    const [muxWindowName, setMuxWindowName] = useState(null);
+    const [muxKind, setMuxKind] = useState(null);
+    async function finalize(path, branch) {
+        const wantsWindow = options.window || options.tmux;
+        if (wantsWindow) {
+            const mux = getMultiplexer();
+            if (!mux.isActive()) {
+                setMessage("Worktree created, but no active multiplexer");
                 setStatus("done");
                 console.log(`SANTREE_CD:${path}`);
                 return;
             }
-            setStatus("tmux");
-            setMessage("Creating tmux window...");
+            setStatus("spawning-window");
+            setMessage(`Creating ${mux.kind} window...`);
             const windowName = getWindowName(branch, options.name);
-            setTmuxWindowName(windowName);
-            // Build command to run in new window (if --work is set)
+            setMuxWindowName(windowName);
+            setMuxKind(mux.kind);
             let runCommand;
             if (options.work) {
                 runCommand = options.plan ? "st worktree work --plan" : "st worktree work";
             }
-            if (!createTmuxWindow(windowName, path, runCommand)) {
-                setMessage("Worktree created, but failed to create tmux window");
+            const result = await mux.createWindow({ name: windowName, cwd: path, command: runCommand });
+            if (!result.ok) {
+                setMessage(`Worktree created, but failed to create ${mux.kind} window${result.message ? `: ${result.message}` : ""}`);
                 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
+            setMessage(`Worktree and ${mux.kind} window created!${workInfo}`);
+            // Don't output SANTREE_CD when a window is created — user is already in the new window
             return;
         }
         setStatus("done");
@@ -133,7 +121,7 @@ export default function Create({ options, args }) {
                     }
                     catch {
                         setMessage("Warning: Init script exists but is not executable");
-                        finalize(result.path, branch);
+                        await finalize(result.path, branch);
                         return;
                     }
                     const initResult = await spawnAsync(initScript, [], {
@@ -147,10 +135,10 @@ export default function Create({ options, args }) {
                     if (initResult.code !== 0) {
                         setMessage(`Warning: Init script exited with code ${initResult.code}`);
                     }
-                    finalize(result.path, branch);
+                    await finalize(result.path, branch);
                 }
                 else {
-                    finalize(result.path, branch);
+                    await finalize(result.path, branch);
                 }
             }
             else {
@@ -165,9 +153,13 @@ export default function Create({ options, args }) {
         options.work,
         options.plan,
         options["no-pull"],
+        options.window,
         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] }))] })] }));
+    const isLoading = status === "pulling" ||
+        status === "creating" ||
+        status === "init-script" ||
+        status === "spawning-window";
+    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.window || options.tmux) && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "window:" }), _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] }), muxWindowName && (_jsxs(Text, { dimColor: true, children: [" ", muxKind ?? "tmux", " window: ", muxWindowName] }))] })), status === "error" && (_jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", message] }))] })] }));
 }

package/dist/commands/worktree/diff.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export declare const description = "View worktree diff against its base branch (uses delta if installed)";
+export declare const options: z.ZodObject<{
+    staged: z.ZodOptional<z.ZodBoolean>;
+    unstaged: z.ZodOptional<z.ZodBoolean>;
+    commits: z.ZodOptional<z.ZodBoolean>;
+    base: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type Props = {
+    options: z.infer<typeof options>;
+};
+export default function Diff({ options: opts }: Props): import("react/jsx-runtime").JSX.Element | null;
+export {};