santree 0.0.1

package/dist/commands/list.d.ts

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

package/dist/commands/list.js

@@ -0,0 +1,106 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Text, Box } from "ink";
+import Spinner from "ink-spinner";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { listWorktrees, getWorktreeMetadata, isWorktreePath, } from "../lib/git.js";
+import { getPRInfoAsync } from "../lib/github.js";
+const execAsync = promisify(exec);
+async function getCommitsAhead(worktreePath, baseBranch) {
+    try {
+        const { stdout } = await execAsync(`git -C "${worktreePath}" rev-list --count ${baseBranch}..HEAD`);
+        return parseInt(stdout.trim(), 10) || 0;
+    }
+    catch {
+        return -1;
+    }
+}
+async function isDirty(worktreePath) {
+    try {
+        const { stdout } = await execAsync(`git -C "${worktreePath}" status --porcelain`);
+        return Boolean(stdout.trim());
+    }
+    catch {
+        return false;
+    }
+}
+export default function List() {
+    const [wtInfo, setWtInfo] = useState([]);
+    const [error, setError] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const [loadingMsg, setLoadingMsg] = useState("Loading worktrees...");
+    useEffect(() => {
+        async function run() {
+            await new Promise((r) => setTimeout(r, 100));
+            try {
+                const worktrees = listWorktrees();
+                const info = [];
+                for (let i = 0; i < worktrees.length; i++) {
+                    const wt = worktrees[i];
+                    setLoadingMsg(`Checking ${i + 1}/${worktrees.length}...`);
+                    const branch = wt.branch || "(detached)";
+                    const isMain = !isWorktreePath(wt.path);
+                    let base = "-";
+                    let ahead = -1;
+                    let pr = "-";
+                    let prState = "";
+                    let status = "-";
+                    if (!isMain) {
+                        const metadata = getWorktreeMetadata(wt.path);
+                        if (metadata?.base_branch) {
+                            base = metadata.base_branch;
+                        }
+                        // Run async operations in parallel
+                        const [aheadResult, dirtyResult, prInfo] = await Promise.all([
+                            base !== "-" ? getCommitsAhead(wt.path, base) : Promise.resolve(-1),
+                            isDirty(wt.path),
+                            wt.branch ? getPRInfoAsync(wt.branch) : Promise.resolve(null),
+                        ]);
+                        ahead = aheadResult;
+                        status = dirtyResult ? "dirty" : "clean";
+                        if (prInfo) {
+                            pr = `#${prInfo.number}`;
+                            prState = prInfo.state;
+                        }
+                    }
+                    info.push({
+                        branch,
+                        base,
+                        ahead,
+                        pr,
+                        prState,
+                        status,
+                        path: wt.path,
+                        isMain,
+                    });
+                }
+                setWtInfo(info);
+                setLoading(false);
+            }
+            catch (e) {
+                setError(e instanceof Error ? e.message : "Unknown error");
+                setLoading(false);
+            }
+        }
+        run();
+    }, []);
+    if (error) {
+        return (_jsx(Box, { padding: 1, children: _jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", error] }) }));
+    }
+    if (loading) {
+        return (_jsxs(Box, { padding: 1, gap: 1, children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { children: loadingMsg })] }));
+    }
+    if (wtInfo.length === 0) {
+        return (_jsx(Box, { padding: 1, children: _jsx(Text, { color: "yellow", children: "No worktrees found" }) }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "\uD83C\uDF33 Worktrees" }), _jsxs(Text, { dimColor: true, children: [" (", wtInfo.length, ")"] })] }), wtInfo.map((w, i) => (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: w.isMain
+                    ? "white"
+                    : w.prState === "MERGED"
+                        ? "magenta"
+                        : w.prState === "CLOSED"
+                            ? "red"
+                            : w.status === "dirty"
+                                ? "yellow"
+                                : "green", paddingX: 1, marginBottom: i < wtInfo.length - 1 ? 1 : 0, children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: w.isMain ? "white" : "cyan", bold: true, children: w.branch }), w.isMain && _jsx(Text, { dimColor: true, children: "(main repo)" })] }), !w.isMain && (_jsxs(_Fragment, { children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "base:" }), _jsx(Text, { children: w.base }), w.ahead > 0 && (_jsxs(Text, { color: "green", bold: true, children: ["+", w.ahead, " ahead"] })), w.ahead === 0 && _jsx(Text, { dimColor: true, children: "up to date" })] }), _jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "status:" }), w.status === "dirty" ? (_jsx(Text, { color: "yellow", bold: true, children: "\u25CF dirty" })) : (_jsx(Text, { color: "green", children: "\u2713 clean" }))] }), _jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "PR:" }), w.pr === "-" ? (_jsx(Text, { dimColor: true, children: "none" })) : w.prState === "MERGED" ? (_jsxs(Text, { color: "magenta", children: [w.pr, " merged"] })) : w.prState === "CLOSED" ? (_jsxs(Text, { color: "red", children: [w.pr, " closed"] })) : (_jsxs(Text, { color: "blue", children: [w.pr, " open"] }))] })] })), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: w.path }) })] }, i)))] }));
+}

package/dist/commands/pr.d.ts

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

package/dist/commands/pr.js

@@ -0,0 +1,154 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Text, Box, useApp } from "ink";
+import TextInput from "ink-text-input";
+import Spinner from "ink-spinner";
+import { z } from "zod";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { findMainRepoRoot, findRepoRoot, getCurrentBranch, getDefaultBranch, getWorktreeMetadata, hasUncommittedChanges, getCommitsAhead, remoteBranchExists, getUnpushedCommits, extractTicketId, isInWorktree, getLatestCommitMessage, } from "../lib/git.js";
+import { ghCliAvailable, getPRInfoAsync, pushBranch, createPR, } from "../lib/github.js";
+const execAsync = promisify(exec);
+export const options = z.object({
+    draft: z.boolean().optional().describe("Create as draft PR"),
+});
+export default function PR({ options }) {
+    const { exit } = useApp();
+    const [status, setStatus] = useState("checking");
+    const [message, setMessage] = useState("");
+    const [branch, setBranch] = useState(null);
+    const [baseBranch, setBaseBranch] = useState(null);
+    const [issueId, setIssueId] = useState(null);
+    const [titleInput, setTitleInput] = useState("");
+    async function handleTitleSubmit(value) {
+        const finalTitle = value.trim();
+        if (!finalTitle) {
+            setStatus("error");
+            setMessage("PR title is required");
+            setTimeout(() => exit(), 100);
+            return;
+        }
+        if (!branch || !baseBranch)
+            return;
+        setStatus("creating");
+        setMessage("Creating PR...");
+        const result = createPR(finalTitle, baseBranch, branch, options.draft ?? false);
+        if (result === 0) {
+            setStatus("done");
+            setMessage("Opened PR creation page in browser");
+        }
+        else {
+            setStatus("error");
+            setMessage("Failed to create PR");
+        }
+        setTimeout(() => exit(), 100);
+    }
+    useEffect(() => {
+        async function run() {
+            // Allow spinner to render first
+            await new Promise((r) => setTimeout(r, 50));
+            // Check gh CLI is available
+            if (!ghCliAvailable()) {
+                setStatus("error");
+                setMessage("GitHub CLI (gh) is not installed. Install with: brew install gh");
+                return;
+            }
+            // Yield to let spinner animate
+            await new Promise((r) => setTimeout(r, 10));
+            // Find repos
+            const mainRepoRoot = findMainRepoRoot();
+            const currentRepo = findRepoRoot();
+            if (!mainRepoRoot || !currentRepo) {
+                setStatus("error");
+                setMessage("Not inside a git repository");
+                return;
+            }
+            // Validate we're in a worktree (not the main repo)
+            if (!isInWorktree()) {
+                setStatus("error");
+                setMessage("Not inside a worktree (you are in the main repository)");
+                return;
+            }
+            // Yield to let spinner animate
+            await new Promise((r) => setTimeout(r, 10));
+            // Get current branch
+            const branchName = getCurrentBranch();
+            if (!branchName) {
+                setStatus("error");
+                setMessage("Could not determine current branch");
+                return;
+            }
+            setBranch(branchName);
+            // Check for uncommitted changes
+            if (hasUncommittedChanges()) {
+                setStatus("error");
+                setMessage("You have uncommitted changes. Please commit your changes before creating a PR.");
+                return;
+            }
+            // Yield to let spinner animate
+            await new Promise((r) => setTimeout(r, 10));
+            // Get base branch from metadata
+            const metadata = getWorktreeMetadata(currentRepo);
+            const base = metadata?.base_branch ?? getDefaultBranch();
+            setBaseBranch(base);
+            // Check commits ahead
+            const commitsAhead = getCommitsAhead(base);
+            if (commitsAhead === 0) {
+                setStatus("error");
+                setMessage(`No commits ahead of ${base}. You need to make commits before creating a PR.`);
+                return;
+            }
+            // Yield to let spinner animate
+            await new Promise((r) => setTimeout(r, 10));
+            // Check if we need to push
+            const remoteExists = remoteBranchExists(branchName);
+            const unpushed = getUnpushedCommits(branchName);
+            if (!remoteExists || unpushed > 0) {
+                setStatus("pushing");
+                setMessage("Pushing to remote...");
+                // Yield before push
+                await new Promise((r) => setTimeout(r, 10));
+                if (!pushBranch(branchName)) {
+                    setStatus("error");
+                    setMessage("Failed to push branch to remote");
+                    return;
+                }
+            }
+            // Check if PR already exists
+            const existingPr = await getPRInfoAsync(branchName);
+            if (existingPr) {
+                setStatus("existing");
+                setMessage(`PR already exists (#${existingPr.number}) - ${existingPr.state}`);
+                if (existingPr.url) {
+                    try {
+                        await execAsync(`open "${existingPr.url}"`);
+                    }
+                    catch {
+                        // Ignore open errors
+                    }
+                }
+                setTimeout(() => exit(), 100);
+                return;
+            }
+            // Get the latest commit message for the PR title
+            const latestCommit = getLatestCommitMessage();
+            let suggestedTitle = latestCommit ?? "";
+            // Extract ticket ID from branch name to display in UI
+            const ticket = extractTicketId(branchName);
+            if (ticket) {
+                setIssueId(ticket);
+            }
+            setTitleInput(suggestedTitle);
+            setStatus("awaiting-title");
+        }
+        run();
+    }, [options.draft]);
+    const isLoading = status === "checking" || status === "pushing" || status === "creating";
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, width: "100%", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "cyan", children: "\uD83D\uDD17 Pull Request" }) }), _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: status === "error"
+                    ? "red"
+                    : status === "done"
+                        ? "green"
+                        : status === "existing"
+                            ? "yellow"
+                            : "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 })] })), baseBranch && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "base:" }), _jsx(Text, { color: "blue", children: baseBranch })] })), issueId && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "issue:" }), _jsx(Text, { color: "blue", bold: true, children: issueId })] })), _jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "type:" }), _jsx(Text, { backgroundColor: options.draft ? "yellow" : "green", color: "black", children: options.draft ? " draft " : " ready " })] })] }), _jsxs(Box, { marginTop: 1, children: [isLoading && (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsxs(Text, { children: [" ", message || "Checking..."] })] })), status === "awaiting-title" && (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", bold: true, children: "PR Title: " }), _jsx(TextInput, { value: titleInput, onChange: setTitleInput, onSubmit: handleTitleSubmit })] })), status === "done" && (_jsxs(Text, { color: "green", bold: true, children: ["\u2713 ", message] })), status === "existing" && (_jsxs(Text, { color: "yellow", bold: true, children: ["\u26A0 ", message] })), status === "error" && (_jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", message] }))] })] }));
+}

package/dist/commands/remove.d.ts

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

package/dist/commands/remove.js

@@ -0,0 +1,41 @@
+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 { removeWorktree, findMainRepoRoot } from "../lib/git.js";
+export const options = z.object({
+    force: z.boolean().optional().describe("Force removal"),
+});
+export const args = z.tuple([z.string().describe("Branch name to remove")]);
+export default function Remove({ options, args }) {
+    const [branchName] = args;
+    const [status, setStatus] = useState("idle");
+    const [message, setMessage] = useState("");
+    useEffect(() => {
+        async function run() {
+            // Small delay to allow spinner to render
+            await new Promise((r) => setTimeout(r, 100));
+            const repoRoot = findMainRepoRoot();
+            if (!repoRoot) {
+                setStatus("error");
+                setMessage("Not inside a git repository");
+                return;
+            }
+            setStatus("removing");
+            setMessage(`Removing worktree ${branchName}...`);
+            const result = await removeWorktree(branchName, repoRoot, options.force ?? false);
+            if (result.success) {
+                setStatus("done");
+                setMessage(`Removed worktree and branch: ${branchName}`);
+            }
+            else {
+                setStatus("error");
+                setMessage(result.error ?? "Unknown error");
+            }
+        }
+        run();
+    }, [branchName, options.force]);
+    const isLoading = status === "idle" || status === "removing";
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, width: "100%", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "cyan", children: "\uD83D\uDDD1\uFE0F Remove" }) }), _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: status === "error" ? "red" : status === "done" ? "green" : "yellow", paddingX: 1, width: "100%", children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "branch:" }), _jsx(Text, { color: "red", bold: true, children: branchName })] }), options.force && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "force:" }), _jsxs(Text, { backgroundColor: "red", color: "white", children: [" ", "yes", " "] })] }))] }), _jsxs(Box, { marginTop: 1, children: [isLoading && (_jsxs(Box, { children: [_jsx(Text, { color: "yellow", children: _jsx(Spinner, { type: "dots" }) }), _jsxs(Text, { children: [" ", message || "Removing..."] })] })), status === "done" && (_jsxs(Text, { color: "green", bold: true, children: ["\u2713 ", message] })), status === "error" && (_jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", message] }))] })] }));
+}

package/dist/commands/setup.d.ts

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

package/dist/commands/setup.js

@@ -0,0 +1,90 @@
+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 { spawn } from "child_process";
+import * as path from "path";
+import * as fs from "fs";
+import { findMainRepoRoot, getSantreeDir, isInWorktree } from "../lib/git.js";
+export default function Setup() {
+    const [status, setStatus] = useState("checking");
+    const [message, setMessage] = useState("");
+    const [worktreePath, setWorktreePath] = useState("");
+    const [scriptPath, setScriptPath] = useState("");
+    const [output, setOutput] = useState("");
+    useEffect(() => {
+        async function run() {
+            // Small delay to allow initial render with spinner
+            await new Promise((r) => setTimeout(r, 100));
+            const mainRepo = findMainRepoRoot();
+            if (!mainRepo) {
+                setStatus("error");
+                setMessage("Not inside a git repository");
+                return;
+            }
+            const santreeDir = getSantreeDir(mainRepo);
+            const initScript = path.join(santreeDir, "init.sh");
+            setScriptPath(initScript);
+            if (!fs.existsSync(initScript)) {
+                setStatus("error");
+                setMessage(`No init script found at ${initScript}`);
+                return;
+            }
+            try {
+                fs.accessSync(initScript, fs.constants.X_OK);
+            }
+            catch {
+                setStatus("error");
+                setMessage(`Init script is not executable. Run: chmod +x ${initScript}`);
+                return;
+            }
+            const cwd = process.cwd();
+            if (!isInWorktree()) {
+                setStatus("error");
+                setMessage("Not inside a worktree (you are in the main repository)");
+                return;
+            }
+            setWorktreePath(cwd);
+            setStatus("running");
+            // Run script and capture output
+            const exitCode = await new Promise((resolve) => {
+                const child = spawn(initScript, [], {
+                    cwd,
+                    stdio: "pipe",
+                    env: {
+                        ...process.env,
+                        SANTREE_WORKTREE_PATH: cwd,
+                        SANTREE_REPO_ROOT: mainRepo,
+                    },
+                });
+                let scriptOutput = "";
+                child.stdout?.on("data", (data) => {
+                    scriptOutput += data.toString();
+                    setOutput(scriptOutput);
+                });
+                child.stderr?.on("data", (data) => {
+                    scriptOutput += data.toString();
+                    setOutput(scriptOutput);
+                });
+                child.on("close", (code) => {
+                    resolve(code ?? 1);
+                });
+                child.on("error", (err) => {
+                    setOutput(err.message);
+                    resolve(1);
+                });
+            });
+            if (exitCode === 0) {
+                setStatus("done");
+                setMessage("Init script completed successfully");
+            }
+            else {
+                setStatus("error");
+                setMessage(`Init script failed (exit code ${exitCode})`);
+            }
+        }
+        run();
+    }, []);
+    const isLoading = status === "checking" || status === "running";
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, width: "100%", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "cyan", children: "\u2699\uFE0F Setup" }) }), _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: status === "error" ? "red" : status === "done" ? "green" : "blue", paddingX: 1, width: "100%", children: [worktreePath && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "worktree:" }), _jsx(Text, { color: "cyan", children: worktreePath })] })), scriptPath && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "script:" }), _jsx(Text, { dimColor: true, children: scriptPath })] }))] }), output && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Output:" }), _jsx(Text, { children: output })] })), _jsxs(Box, { marginTop: 1, children: [isLoading && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { children: status === "checking" ? "Checking..." : "Running init script..." })] })), status === "done" && (_jsxs(Text, { color: "green", bold: true, children: ["\u2713 ", message] })), status === "error" && (_jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", message] }))] })] }));
+}

package/dist/commands/switch.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export declare const args: z.ZodTuple<[z.ZodString], null>;
+type Props = {
+    args: z.infer<typeof args>;
+};
+export default function Switch({ args }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/commands/switch.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef } from "react";
+import { Text, Box } from "ink";
+import { z } from "zod";
+import { getWorktreePath } from "../lib/git.js";
+export const args = z.tuple([z.string().describe("Branch name to switch to")]);
+export default function Switch({ args }) {
+    const [branchName] = args;
+    const hasOutputRef = useRef(false);
+    // Find worktree path synchronously
+    const worktreePath = getWorktreePath(branchName);
+    // Output SANTREE_CD once (before Ink fully renders)
+    useEffect(() => {
+        if (worktreePath && !hasOutputRef.current) {
+            hasOutputRef.current = true;
+            process.stdout.write(`SANTREE_CD:${worktreePath}\n`);
+        }
+    }, [worktreePath]);
+    const status = worktreePath ? "done" : "error";
+    const error = worktreePath ? null : `Worktree not found for branch: ${branchName}`;
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, width: "100%", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "cyan", children: "\uD83D\uDD00 Switch" }) }), _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: status === "error" ? "red" : "green", paddingX: 1, width: "100%", children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "branch:" }), _jsx(Text, { color: "cyan", bold: true, children: branchName })] }), worktreePath && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "path:" }), _jsx(Text, { dimColor: true, children: worktreePath })] }))] }), _jsxs(Box, { marginTop: 1, children: [status === "done" && (_jsx(Text, { color: "green", bold: true, children: "\u2713 Switching to worktree" })), status === "error" && (_jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", error] }))] })] }));
+}

package/dist/commands/sync.d.ts

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

package/dist/commands/sync.js

@@ -0,0 +1,108 @@
+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 { spawn } from "child_process";
+import { z } from "zod";
+import { findMainRepoRoot, findRepoRoot, getCurrentBranch, getDefaultBranch, getWorktreeMetadata, hasUncommittedChanges, getCommitsBehind, isInWorktree, } from "../lib/git.js";
+export const options = z.object({
+    rebase: z.boolean().optional().describe("Use rebase instead of merge"),
+});
+function runCommand(cmd, args) {
+    return new Promise((resolve) => {
+        const child = spawn(cmd, args, { stdio: "pipe" });
+        let output = "";
+        child.stdout?.on("data", (data) => {
+            output += data.toString();
+        });
+        child.stderr?.on("data", (data) => {
+            output += data.toString();
+        });
+        child.on("close", (code) => {
+            resolve({ code: code ?? 1, output });
+        });
+        child.on("error", (err) => {
+            resolve({ code: 1, output: err.message });
+        });
+    });
+}
+export default function Sync({ options }) {
+    const [status, setStatus] = useState("init");
+    const [message, setMessage] = useState("");
+    const [branch, setBranch] = useState(null);
+    const [baseBranch, setBaseBranch] = useState(null);
+    const [commitsBehind, setCommitsBehind] = useState(0);
+    const usesRebase = options.rebase ?? false;
+    useEffect(() => {
+        async function run() {
+            // Small delay to allow initial render with spinner
+            await new Promise((r) => setTimeout(r, 100));
+            // Find repos
+            const mainRepo = findMainRepoRoot();
+            const currentRepo = findRepoRoot();
+            if (!mainRepo || !currentRepo) {
+                setStatus("error");
+                setMessage("Not inside a git repository");
+                return;
+            }
+            if (!isInWorktree()) {
+                setStatus("error");
+                setMessage("Not inside a worktree (you are in the main repository)");
+                return;
+            }
+            const branchName = getCurrentBranch();
+            if (!branchName) {
+                setStatus("error");
+                setMessage("Could not determine current branch");
+                return;
+            }
+            setBranch(branchName);
+            const metadata = getWorktreeMetadata(currentRepo);
+            const base = metadata?.base_branch ?? getDefaultBranch();
+            setBaseBranch(base);
+            if (hasUncommittedChanges()) {
+                setStatus("error");
+                setMessage("You have uncommitted changes. Please commit or stash them before syncing.");
+                return;
+            }
+            // Fetch
+            setStatus("fetching");
+            const fetchResult = await runCommand("git", ["fetch", "origin"]);
+            if (fetchResult.code !== 0) {
+                setStatus("error");
+                setMessage("Failed to fetch from remote");
+                return;
+            }
+            // Check behind
+            const behind = getCommitsBehind(base);
+            setCommitsBehind(behind);
+            if (behind === 0) {
+                setStatus("up-to-date");
+                setMessage(`Already up to date with origin/${base}`);
+                return;
+            }
+            // Sync
+            setStatus("syncing");
+            const cmd = usesRebase ? "rebase" : "merge";
+            const syncResult = await runCommand("git", [cmd, `origin/${base}`]);
+            if (syncResult.code === 0) {
+                setStatus("done");
+                setMessage(`Successfully synced with origin/${base}`);
+            }
+            else {
+                setStatus("error");
+                setMessage(usesRebase
+                    ? "Rebase failed - resolve conflicts and run: git rebase --continue"
+                    : "Merge failed - resolve conflicts and run: git commit");
+            }
+        }
+        run();
+    }, [usesRebase]);
+    const isLoading = status === "init" || status === "fetching" || status === "syncing";
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, width: "100%", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "cyan", children: "\uD83D\uDD04 Sync" }) }), _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: status === "error"
+                    ? "red"
+                    : status === "done" || status === "up-to-date"
+                        ? "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 })] })), baseBranch && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "base:" }), _jsx(Text, { color: "blue", children: baseBranch })] })), commitsBehind > 0 && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "behind:" }), _jsxs(Text, { color: "yellow", bold: true, children: ["\u2193", commitsBehind] })] })), _jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "mode:" }), _jsx(Text, { backgroundColor: usesRebase ? "blue" : "magenta", color: "white", children: usesRebase ? " rebase " : " merge " })] })] }), _jsxs(Box, { marginTop: 1, children: [isLoading && (_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsxs(Text, { children: [status === "init" && "Starting...", status === "fetching" && "Fetching from remote...", status === "syncing" &&
+                                        (usesRebase ? "Rebasing..." : "Merging...")] })] })), (status === "done" || status === "up-to-date") && (_jsxs(Text, { color: "green", bold: true, children: ["\u2713 ", message] })), status === "error" && (_jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", message] }))] })] }));
+}

package/dist/commands/work.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export declare const options: z.ZodObject<{
+    plan: z.ZodOptional<z.ZodBoolean>;
+    review: z.ZodOptional<z.ZodBoolean>;
+    "fix-pr": z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type Props = {
+    options: z.infer<typeof options>;
+};
+export default function Work({ options }: Props): import("react/jsx-runtime").JSX.Element;
+export {};