mintree 0.1.2

package/dist/commands/init.js

@@ -0,0 +1,129 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Box, Text } from "ink";
+import Spinner from "ink-spinner";
+import * as fs from "fs";
+import { findMainRepoRoot, getMintreeDir, getMetadataPath, getWorktreesDir, getSessionStatesDir, ensureGitignoreEntries, isGitTracked, } from "../lib/git.js";
+export const description = "Initialize the current repo for mintree (creates .mintree/, updates .gitignore)";
+const METADATA_TEMPLATE = {
+    version: 1,
+    issues: {},
+};
+function ensureDir(p, label, steps) {
+    if (fs.existsSync(p)) {
+        steps.push({ kind: "exists", label });
+    }
+    else {
+        fs.mkdirSync(p, { recursive: true });
+        steps.push({ kind: "created", label });
+    }
+}
+function ensureMetadata(metadataPath, steps) {
+    if (fs.existsSync(metadataPath)) {
+        steps.push({ kind: "exists", label: ".mintree/metadata.json" });
+        return;
+    }
+    fs.writeFileSync(metadataPath, JSON.stringify(METADATA_TEMPLATE, null, 2) + "\n");
+    steps.push({ kind: "created", label: ".mintree/metadata.json" });
+}
+function runInit() {
+    const root = findMainRepoRoot();
+    if (!root) {
+        return {
+            ok: false,
+            message: "Not in a git repository.",
+            hint: "Run `git init` first, then re-run `mintree init`.",
+        };
+    }
+    const steps = [];
+    const mintreeDir = getMintreeDir(root);
+    const worktreesDir = getWorktreesDir(root);
+    const sessionStatesDir = getSessionStatesDir(root);
+    const metadataPath = getMetadataPath(root);
+    ensureDir(mintreeDir, ".mintree/", steps);
+    ensureDir(worktreesDir, ".mintree/worktrees/", steps);
+    ensureDir(sessionStatesDir, ".mintree/session-states/", steps);
+    ensureMetadata(metadataPath, steps);
+    // metadata.json holds the per-issue session_id, which is local-only by
+    // nature (each dev gets their own UUIDs from `claude`). Versioning it
+    // would only generate noise + merge conflicts, so it's gitignored along
+    // with the worktrees and session-states directories.
+    const ignoreCandidates = [
+        ".mintree/worktrees/",
+        ".mintree/session-states/",
+        ".mintree/metadata.json",
+    ];
+    const added = ensureGitignoreEntries(root, ignoreCandidates);
+    for (const entry of ignoreCandidates) {
+        steps.push({
+            kind: added.includes(entry) ? "added" : "ignored",
+            label: `${entry} → .gitignore`,
+        });
+    }
+    // If metadata.json was committed before being gitignored (likely on a
+    // repo that ran an earlier mintree version), gitignore alone won't
+    // stop git from tracking it. Surface an actionable hint so the user
+    // knows exactly what to run.
+    if (isGitTracked(".mintree/metadata.json", root)) {
+        steps.push({
+            kind: "warn",
+            label: ".mintree/metadata.json is currently tracked by git",
+            hint: "Run: git rm --cached .mintree/metadata.json && git commit -m 'chore: untrack mintree metadata'",
+        });
+    }
+    return { ok: true, repoRoot: root, steps };
+}
+function StepIcon({ kind }) {
+    switch (kind) {
+        case "created":
+        case "added":
+            return _jsx(Text, { color: "green", children: "\u2713" });
+        case "exists":
+        case "ignored":
+            return _jsx(Text, { color: "cyan", children: "\u25CB" });
+        case "warn":
+            return _jsx(Text, { color: "yellow", children: "!" });
+    }
+}
+function stepDetail(kind) {
+    switch (kind) {
+        case "created":
+            return "created";
+        case "exists":
+            return "already exists";
+        case "added":
+            return "added";
+        case "ignored":
+            return "already ignored";
+        case "warn":
+            return null;
+    }
+}
+export default function Init() {
+    const [result, setResult] = useState(null);
+    useEffect(() => {
+        // Defer one tick so the initial render with the spinner gets to paint.
+        setTimeout(() => {
+            try {
+                setResult(runInit());
+            }
+            catch (err) {
+                setResult({
+                    ok: false,
+                    message: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }, 0);
+    }, []);
+    if (!result) {
+        return (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { children: " Initializing mintree..." })] }));
+    }
+    if (!result.ok) {
+        return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", result.message] }), result.hint && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "yellow", children: ["\u21B3 ", result.hint] }) }))] }));
+    }
+    const anyChange = result.steps.some(s => s.kind === "created" || s.kind === "added");
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "mintree init" }), _jsxs(Text, { dimColor: true, children: [" \u00B7 ", result.repoRoot] })] }), result.steps.map((step, i) => {
+                const detail = stepDetail(step.kind);
+                return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(StepIcon, { kind: step.kind }), _jsx(Text, { children: " " }), _jsx(Text, { children: step.label }), detail && _jsxs(Text, { dimColor: true, children: [" (", detail, ")"] })] }), step.hint && (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: "yellow", children: ["\u21B3 ", step.hint] }) }))] }, i));
+            }), _jsx(Box, { marginTop: 1, children: anyChange ? (_jsxs(Text, { color: "green", children: ["mintree initialized. Run ", _jsx(Text, { bold: true, children: "mintree doctor" }), " to verify the rest of your setup."] })) : (_jsx(Text, { color: "cyan", children: "mintree was already initialized \u2014 nothing to do." })) })] }));
+}

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

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export declare const description = "Remove worktrees whose PR is merged or closed";
+export declare const options: z.ZodObject<{
+    yes: z.ZodDefault<z.ZodBoolean>;
+    force: z.ZodDefault<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/worktree/clean.js

@@ -0,0 +1,206 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Box, Text, useApp, useInput } from "ink";
+import Spinner from "ink-spinner";
+import { option } from "pastel";
+import { z } from "zod";
+import * as path from "path";
+import { findMainRepoRoot, getMintreeDir, getWorktreesDir, listWorktrees, isDirty, removeWorktree, pathExists, } from "../../lib/git.js";
+import { tryExec } from "../../lib/exec.js";
+export const description = "Remove worktrees whose PR is merged or closed";
+export const options = z.object({
+    yes: z
+        .boolean()
+        .default(false)
+        .describe(option({
+        description: "Skip the confirmation prompt (required for non-interactive shells)",
+    })),
+    force: z
+        .boolean()
+        .default(false)
+        .describe(option({
+        description: "Include worktrees with uncommitted changes (clean is conservative by default)",
+    })),
+});
+function shQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+async function fetchPr(branch) {
+    const out = await tryExec(`gh pr list --head ${shQuote(branch)} --state all --json number,state --limit 1 2>/dev/null`);
+    if (!out)
+        return null;
+    try {
+        const arr = JSON.parse(out);
+        if (Array.isArray(arr) && arr.length > 0 && arr[0])
+            return arr[0];
+    }
+    catch {
+        // fall through
+    }
+    return null;
+}
+async function loadCandidates(force) {
+    const root = findMainRepoRoot();
+    if (!root) {
+        return {
+            phase: "error",
+            message: "Not in a git repository.",
+            hint: "Run `git init` and then `mintree init`.",
+        };
+    }
+    if (!pathExists(getMintreeDir(root))) {
+        return {
+            phase: "error",
+            message: ".mintree/ not found in this repo.",
+            hint: "Run `mintree init` first.",
+        };
+    }
+    const worktreesDir = getWorktreesDir(root);
+    const all = listWorktrees(root);
+    const ours = all.filter((w) => {
+        if (!w.branch)
+            return false;
+        const wAbs = path.resolve(w.path);
+        const dirAbs = path.resolve(worktreesDir);
+        return wAbs === dirAbs || wAbs.startsWith(dirAbs + path.sep);
+    });
+    if (ours.length === 0) {
+        return { phase: "nothing", message: "No mintree worktrees in this repo. Nothing to clean." };
+    }
+    const prs = await Promise.all(ours.map(w => fetchPr(w.branch)));
+    const candidates = [];
+    for (let i = 0; i < ours.length; i++) {
+        const w = ours[i];
+        const pr = prs[i];
+        if (!w || !w.branch)
+            continue;
+        if (!pr || pr.state === "OPEN")
+            continue; // only candidates with closed/merged PRs
+        const dirty = pathExists(w.path) ? isDirty(w.path) : false;
+        const skipForDirty = dirty && !force;
+        candidates.push({
+            worktreePath: w.path,
+            branch: w.branch,
+            dirty,
+            pr,
+            willClean: !skipForDirty,
+            reasonSkipped: skipForDirty ? "dirty (pass --force to include)" : undefined,
+        });
+    }
+    if (candidates.length === 0) {
+        return {
+            phase: "nothing",
+            message: "All mintree worktrees still have an open PR (or no PR at all). Nothing to clean.",
+        };
+    }
+    return { phase: "prompt", repoRoot: root, candidates };
+}
+function executeRemovals(repoRoot, candidates) {
+    const toRemove = candidates.filter(c => c.willClean);
+    const results = [];
+    for (const c of toRemove) {
+        try {
+            removeWorktree({ repoRoot, worktreePath: c.worktreePath, force: c.dirty });
+            results.push({ branch: c.branch, ok: true });
+        }
+        catch (err) {
+            const stderr = err && typeof err === "object" && "stderr" in err
+                ? String(err.stderr).trim()
+                : err instanceof Error
+                    ? err.message
+                    : String(err);
+            results.push({ branch: c.branch, ok: false, error: stderr });
+        }
+    }
+    return results;
+}
+function PrTag({ pr }) {
+    const color = pr.state === "MERGED" ? "magenta" : pr.state === "CLOSED" ? "yellow" : "green";
+    return (_jsxs(Text, { children: [_jsxs(Text, { children: ["#", pr.number] }), " ", _jsx(Text, { color: color, children: pr.state })] }));
+}
+export default function Clean({ options }) {
+    const { exit } = useApp();
+    const [state, setState] = useState({ phase: "loading", message: "Inspecting worktrees..." });
+    useEffect(() => {
+        (async () => {
+            try {
+                const next = await loadCandidates(options.force);
+                if (next.phase === "prompt") {
+                    // In non-interactive environments useInput will never fire, so we
+                    // require --yes up front rather than hanging the user.
+                    if (!process.stdin.isTTY && !options.yes) {
+                        setState({
+                            phase: "error",
+                            message: "Confirmation required but stdin is not a TTY (running non-interactive).",
+                            hint: "Re-run with `--yes` to skip the prompt.",
+                        });
+                        return;
+                    }
+                    if (options.yes) {
+                        setState({
+                            phase: "executing",
+                            repoRoot: next.repoRoot,
+                            candidates: next.candidates,
+                        });
+                        return;
+                    }
+                }
+                setState(next);
+            }
+            catch (err) {
+                setState({
+                    phase: "error",
+                    message: err instanceof Error ? err.message : String(err),
+                });
+            }
+        })();
+    }, [options.force, options.yes]);
+    useEffect(() => {
+        if (state.phase === "executing") {
+            const results = executeRemovals(state.repoRoot, state.candidates);
+            setState({ phase: "done", results, cancelled: false });
+        }
+    }, [state.phase]);
+    useEffect(() => {
+        if (state.phase === "done" || state.phase === "error" || state.phase === "nothing") {
+            // Defer one tick so the final UI paints before Ink unmounts.
+            const t = setTimeout(() => exit(), 50);
+            return () => clearTimeout(t);
+        }
+        return;
+    }, [state.phase, exit]);
+    useInput((input, key) => {
+        if (state.phase !== "prompt")
+            return;
+        if (input === "y" || input === "Y") {
+            setState({
+                phase: "executing",
+                repoRoot: state.repoRoot,
+                candidates: state.candidates,
+            });
+        }
+        else if (input === "n" || input === "N" || key.return || key.escape) {
+            setState({ phase: "done", results: [], cancelled: true });
+        }
+    }, { isActive: state.phase === "prompt" });
+    if (state.phase === "loading") {
+        return (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsxs(Text, { children: [" ", state.message] })] }));
+    }
+    if (state.phase === "error") {
+        return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", state.message] }), state.hint && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "yellow", children: ["\u21B3 ", state.hint] }) }))] }));
+    }
+    if (state.phase === "nothing") {
+        return (_jsx(Box, { padding: 1, children: _jsx(Text, { dimColor: true, children: state.message }) }));
+    }
+    if (state.phase === "prompt" || state.phase === "executing") {
+        const willCleanCount = state.candidates.filter(c => c.willClean).length;
+        return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "mintree worktree clean" }), _jsxs(Text, { dimColor: true, children: [" \u00B7 ", state.candidates.length, " candidate(s)"] })] }), state.candidates.map((c, i) => (_jsxs(Box, { children: [_jsx(Text, { color: c.willClean ? "green" : "yellow", children: c.willClean ? "✓" : "○" }), _jsx(Text, { children: " " }), _jsx(Text, { color: "cyan", children: c.branch }), _jsx(Text, { children: " " }), _jsx(PrTag, { pr: c.pr }), c.dirty && _jsx(Text, { color: "yellow", children: " [dirty]" }), c.reasonSkipped && _jsxs(Text, { dimColor: true, children: [" \u2014 ", c.reasonSkipped] })] }, i))), _jsx(Box, { marginTop: 1, children: state.phase === "prompt" ? (_jsxs(Text, { children: ["Remove ", willCleanCount, " worktree(s)?", " ", _jsx(Text, { bold: true, children: "[y/N]" })] })) : (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { children: " Removing..." })] })) })] }));
+    }
+    // state.phase === "done"
+    if (state.cancelled) {
+        return (_jsx(Box, { padding: 1, children: _jsx(Text, { dimColor: true, children: "Cancelled. No worktrees were removed." }) }));
+    }
+    const okCount = state.results.filter(r => r.ok).length;
+    const failCount = state.results.length - okCount;
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "cyan", children: "mintree worktree clean \u00B7 done" }) }), state.results.map((r, i) => (_jsxs(Box, { children: [_jsx(Text, { color: r.ok ? "green" : "red", children: r.ok ? "✓" : "✗" }), _jsx(Text, { children: " " }), _jsx(Text, { color: "cyan", children: r.branch }), !r.ok && _jsxs(Text, { color: "red", children: [" \u2014 ", r.error] })] }, i))), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: ["Removed ", okCount, failCount > 0 && (_jsxs(_Fragment, { children: [", ", _jsxs(Text, { color: "red", children: [failCount, " failed"] })] })), ". Branches and metadata preserved."] }) })] }));
+}

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

@@ -0,0 +1,18 @@
+import { z } from "zod";
+export declare const description = "Create a worktree for an issue branch";
+export declare const args: z.ZodTuple<[z.ZodString], null>;
+export declare const options: z.ZodObject<{
+    base: z.ZodOptional<z.ZodString>;
+    work: z.ZodDefault<z.ZodBoolean>;
+    prompt: z.ZodOptional<z.ZodString>;
+    permissionMode: z.ZodOptional<z.ZodEnum<{
+        default: "default";
+        auto: "auto";
+    }>>;
+}, z.core.$strip>;
+type Props = {
+    args: z.infer<typeof args>;
+    options: z.infer<typeof options>;
+};
+export default function Create({ args, options }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/commands/worktree/create.js

@@ -0,0 +1,93 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Box, Text } from "ink";
+import Spinner from "ink-spinner";
+import { argument, option } from "pastel";
+import { z } from "zod";
+import { PERMISSION_MODES } from "../../lib/claude.js";
+import { runCreate } from "../../lib/worktreeCreate.js";
+import { buildCreateMarkers, emitMarkers } from "../../lib/markers.js";
+export const description = "Create a worktree for an issue branch";
+export const args = z.tuple([
+    z
+        .string()
+        .describe(argument({
+        name: "branch",
+        description: "Branch in `<type>/<issue>-<kebab-desc>` format (e.g. feat/100-claude-md-inicial)",
+    })),
+]);
+export const options = z.object({
+    base: z
+        .string()
+        .optional()
+        .describe(option({
+        description: "Base branch to fork from (defaults to origin/HEAD or main/master)",
+    })),
+    work: z
+        .boolean()
+        .default(false)
+        .describe(option({
+        description: "After creating, launch Claude in the new worktree (requires the shell wrapper)",
+    })),
+    prompt: z
+        .string()
+        .optional()
+        .describe(option({
+        description: "Initial prompt to inject into Claude (only meaningful with --work; literal injection)",
+    })),
+    permissionMode: z
+        .enum(PERMISSION_MODES)
+        .optional()
+        .describe(option({
+        description: `Claude --permission-mode passed through to --work (one of: ${PERMISSION_MODES.join(", ")})`,
+        alias: "m",
+    })),
+});
+function StepIcon({ kind }) {
+    if (kind === "ok")
+        return _jsx(Text, { color: "green", children: "\u2713" });
+    if (kind === "warn")
+        return _jsx(Text, { color: "yellow", children: "!" });
+    return _jsx(Text, { color: "cyan", children: "\u25CB" });
+}
+export default function Create({ args, options }) {
+    const [branch] = args;
+    const [result, setResult] = useState(null);
+    useEffect(() => {
+        setTimeout(() => {
+            try {
+                setResult(runCreate(branch, {
+                    base: options.base,
+                    work: options.work,
+                    prompt: options.prompt,
+                    permissionMode: options.permissionMode,
+                }));
+            }
+            catch (err) {
+                setResult({ ok: false, message: err instanceof Error ? err.message : String(err) });
+            }
+        }, 0);
+    }, [branch, options.base, options.work, options.prompt, options.permissionMode]);
+    // Emit shell-wrapper markers when create succeeded. Goes through the
+    // emitMarkers helper so it lands in MINTREE_MARKER_FILE if set, otherwise
+    // stdout. Bypasses Ink so word-wrap can't split a long path mid-marker.
+    useEffect(() => {
+        if (!result || !result.ok)
+            return;
+        emitMarkers(buildCreateMarkers({
+            worktreePath: result.worktreePath,
+            work: result.work,
+            promptFile: result.promptFile,
+            permissionMode: result.permissionMode,
+        }));
+    }, [result]);
+    if (!result) {
+        return (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsxs(Text, { children: [" Creating worktree for ", branch, "..."] })] }));
+    }
+    if (!result.ok) {
+        return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", result.message] }), result.hint && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "yellow", children: ["\u21B3 ", result.hint] }) }))] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "mintree worktree create" }), _jsxs(Text, { dimColor: true, children: [" \u00B7 ", result.branch] })] }), result.steps.map((step, i) => (_jsxs(Box, { children: [_jsx(StepIcon, { kind: step.kind }), _jsx(Text, { children: " " }), _jsx(Text, { children: step.label }), step.detail && _jsxs(Text, { dimColor: true, children: [" (", step.detail, ")"] })] }, i))), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { color: "green", children: ["Worktree ready at ", _jsx(Text, { bold: true, children: result.worktreePath })] }), _jsx(Text, { dimColor: true, children: result.work
+                            ? "Launching Claude in the new worktree..."
+                            : "Next: `mt worktree work` to start a Claude session, or `cd` and run `claude` directly." })] })] }));
+}

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

@@ -0,0 +1 @@
+export declare const description = "Manage mintree worktrees (create, list, remove, ...)";

package/dist/commands/worktree/index.js

@@ -0,0 +1 @@
+export const description = "Manage mintree worktrees (create, list, remove, ...)";

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

@@ -0,0 +1,10 @@
+import { z } from "zod";
+export declare const description = "List mintree-managed worktrees with dirty/ahead/PR status";
+export declare const options: z.ZodObject<{
+    pr: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type Props = {
+    options: z.infer<typeof options>;
+};
+export default function List({ options }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/commands/worktree/list.js

@@ -0,0 +1,143 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Box, Text } from "ink";
+import Spinner from "ink-spinner";
+import { option } from "pastel";
+import { z } from "zod";
+import * as path from "path";
+import { findMainRepoRoot, getWorktreesDir, listWorktrees, isDirty, getAheadBehind, pathExists, getMintreeDir, } from "../../lib/git.js";
+import { readMetadata } from "../../lib/metadata.js";
+import { tryExec } from "../../lib/exec.js";
+export const description = "List mintree-managed worktrees with dirty/ahead/PR status";
+export const options = z.object({
+    pr: z
+        .boolean()
+        .default(false)
+        .describe(option({ description: "Look up PR status for each branch via `gh` (slower)" })),
+});
+const ISSUE_ID_REGEX = /^[a-z]+\/(\d+)-/;
+function extractIssueId(branch) {
+    if (!branch)
+        return null;
+    const m = branch.match(ISSUE_ID_REGEX);
+    return m && m[1] ? m[1] : null;
+}
+async function fetchPrStatus(branch) {
+    const out = await tryExec(`gh pr list --head ${shQuote(branch)} --state all --json number,state --limit 1 2>/dev/null`);
+    if (!out)
+        return undefined;
+    try {
+        const arr = JSON.parse(out);
+        if (Array.isArray(arr) && arr.length > 0 && arr[0]) {
+            return { number: arr[0].number, state: arr[0].state };
+        }
+    }
+    catch {
+        // fall through
+    }
+    return undefined;
+}
+function shQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+async function load(checkPr) {
+    const root = findMainRepoRoot();
+    if (!root) {
+        return {
+            phase: "error",
+            message: "Not in a git repository.",
+            hint: "Run `git init` and then `mintree init`.",
+        };
+    }
+    if (!pathExists(getMintreeDir(root))) {
+        return {
+            phase: "error",
+            message: ".mintree/ not found in this repo.",
+            hint: "Run `mintree init` first.",
+        };
+    }
+    const worktreesDir = getWorktreesDir(root);
+    const all = listWorktrees(root);
+    const ours = all.filter(w => {
+        // Filter to worktrees that live under .mintree/worktrees/. macOS reports
+        // /private/tmp paths so use a relative-prefix check after resolving both
+        // to absolute.
+        const wAbs = path.resolve(w.path);
+        const dirAbs = path.resolve(worktreesDir);
+        return wAbs === dirAbs || wAbs.startsWith(dirAbs + path.sep);
+    });
+    if (ours.length === 0) {
+        return { phase: "empty", repoRoot: root };
+    }
+    const metadata = readMetadata(root);
+    const rows = ours.map(w => {
+        const issueId = extractIssueId(w.branch);
+        const baseFromMeta = issueId ? metadata.issues[issueId]?.base_branch : undefined;
+        return {
+            worktreePath: w.path,
+            branch: w.branch ?? "(detached)",
+            issueId,
+            dirty: isDirty(w.path),
+            ab: getAheadBehind(w.path, baseFromMeta),
+        };
+    });
+    if (checkPr) {
+        const prResults = await Promise.all(rows.map(r => (r.branch === "(detached)" ? Promise.resolve(undefined) : fetchPrStatus(r.branch))));
+        rows.forEach((r, i) => {
+            r.pr = prResults[i];
+        });
+    }
+    return { phase: "ready", repoRoot: root, rows, checkedPr: checkPr };
+}
+function StatusCell({ dirty }) {
+    return dirty ? _jsx(Text, { color: "yellow", children: "dirty" }) : _jsx(Text, { color: "green", children: "clean" });
+}
+function AheadBehindCell({ ab }) {
+    if (!ab)
+        return _jsx(Text, { dimColor: true, children: "\u2014" });
+    const isUp = ab.ahead === 0 && ab.behind === 0;
+    if (isUp)
+        return _jsx(Text, { dimColor: true, children: "=" });
+    return (_jsxs(Text, { children: [_jsxs(Text, { color: ab.ahead > 0 ? "cyan" : undefined, children: ["+", ab.ahead] }), _jsx(Text, { dimColor: true, children: " / " }), _jsxs(Text, { color: ab.behind > 0 ? "magenta" : undefined, children: ["-", ab.behind] })] }));
+}
+function PrCell({ pr, checked }) {
+    if (!checked)
+        return null;
+    if (!pr)
+        return _jsx(Text, { dimColor: true, children: "\u2014" });
+    const color = pr.state === "OPEN" ? "green" : pr.state === "MERGED" ? "magenta" : "yellow";
+    return (_jsxs(Text, { children: [_jsxs(Text, { children: ["#", pr.number] }), _jsx(Text, { dimColor: true, children: " " }), _jsx(Text, { color: color, children: pr.state })] }));
+}
+function pad(s, width) {
+    if (s.length >= width)
+        return s;
+    return s + " ".repeat(width - s.length);
+}
+export default function List({ options }) {
+    const [state, setState] = useState({ phase: "loading" });
+    useEffect(() => {
+        (async () => {
+            try {
+                setState(await load(options.pr));
+            }
+            catch (err) {
+                setState({
+                    phase: "error",
+                    message: err instanceof Error ? err.message : String(err),
+                });
+            }
+        })();
+    }, [options.pr]);
+    if (state.phase === "loading") {
+        return (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsxs(Text, { children: [" Listing worktrees", options.pr ? " (checking PR status)" : "", "..."] })] }));
+    }
+    if (state.phase === "error") {
+        return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", state.message] }), state.hint && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "yellow", children: ["\u21B3 ", state.hint] }) }))] }));
+    }
+    if (state.phase === "empty") {
+        return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Text, { dimColor: true, children: ["No mintree worktrees in ", state.repoRoot, "."] }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: ["Create one with ", _jsx(Text, { bold: true, children: "mintree worktree create <branch>" }), "."] }) })] }));
+    }
+    const issueWidth = Math.max(5, ...state.rows.map(r => (r.issueId ?? "—").length));
+    const branchWidth = Math.max(6, ...state.rows.map(r => r.branch.length));
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { bold: true, children: pad("ISSUE", issueWidth) }), _jsx(Text, { children: "  " }), _jsx(Text, { bold: true, children: pad("BRANCH", branchWidth) }), _jsx(Text, { children: "  " }), _jsx(Text, { bold: true, children: "STATUS" }), _jsx(Text, { children: "   " }), _jsx(Text, { bold: true, children: "\u0394" }), _jsx(Text, { children: "           " }), state.checkedPr && _jsx(Text, { bold: true, children: "PR" })] }), state.rows.map((r, i) => (_jsxs(Box, { children: [_jsx(Text, { children: pad(r.issueId ?? "—", issueWidth) }), _jsx(Text, { children: "  " }), _jsx(Text, { color: "cyan", children: pad(r.branch, branchWidth) }), _jsx(Text, { children: "  " }), _jsx(Box, { width: 9, children: _jsx(StatusCell, { dirty: r.dirty }) }), _jsx(Box, { width: 12, children: _jsx(AheadBehindCell, { ab: r.ab }) }), _jsx(PrCell, { pr: r.pr, checked: state.checkedPr })] }, i)))] }));
+}

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

@@ -0,0 +1,12 @@
+import { z } from "zod";
+export declare const description = "Remove a worktree (the branch and metadata are preserved so you can re-attach later)";
+export declare const args: z.ZodTuple<[z.ZodString], null>;
+export declare const options: z.ZodObject<{
+    force: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type Props = {
+    args: z.infer<typeof args>;
+    options: z.infer<typeof options>;
+};
+export default function Remove({ args, options }: Props): import("react/jsx-runtime").JSX.Element;
+export {};