mintree 0.1.2

package/dist/commands/doctor.d.ts

@@ -0,0 +1,2 @@
+export declare const description = "Check system requirements and Claude Code integrations";
+export default function Doctor(): import("react/jsx-runtime").JSX.Element;

package/dist/commands/doctor.js

@@ -0,0 +1,327 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } 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 * as path from "path";
+import { createRequire } from "module";
+import { tryExec, getPath } from "../lib/exec.js";
+import { ghCliAvailable, getGhUserLogin, getRepoFullName } from "../lib/github.js";
+import { resolveClaudeBinary } from "../lib/claude.js";
+import { findMainRepoRoot, getMintreeDir, getInitScriptPath, isGitIgnored, isExecutable, pathExists, } from "../lib/git.js";
+const require = createRequire(import.meta.url);
+const { version } = require("../../package.json");
+export const description = "Check system requirements and Claude Code integrations";
+async function checkTool(name, description, required, versionCommand, hint) {
+    const binPath = await getPath(name);
+    if (!binPath) {
+        return { name, description, required, installed: false, hint };
+    }
+    const ver = await tryExec(versionCommand);
+    return {
+        name,
+        description,
+        required,
+        installed: true,
+        version: ver || "unknown",
+        path: binPath,
+    };
+}
+async function checkClaude() {
+    const resolved = resolveClaudeBinary();
+    if (!resolved) {
+        return {
+            name: "claude",
+            description: "Claude Code CLI",
+            required: true,
+            installed: false,
+            hint: "Install: npm install -g @anthropic-ai/claude-code",
+        };
+    }
+    const ver = await tryExec(`"${resolved}" --version 2>/dev/null | head -1`);
+    return {
+        name: "claude",
+        description: "Claude Code CLI",
+        required: true,
+        installed: true,
+        version: ver || "unknown",
+        path: resolved,
+    };
+}
+async function checkGh() {
+    const binPath = await getPath("gh");
+    if (!binPath) {
+        return {
+            name: "gh",
+            description: "GitHub CLI for issues + PRs",
+            required: true,
+            installed: false,
+            hint: "Install: brew install gh && gh auth login",
+        };
+    }
+    const ver = await tryExec("gh --version | head -1");
+    const login = await getGhUserLogin();
+    if (!login) {
+        return {
+            name: "gh",
+            description: "GitHub CLI for issues + PRs",
+            required: true,
+            installed: true,
+            version: ver || "unknown",
+            path: binPath,
+            hint: "Run: gh auth login",
+        };
+    }
+    return {
+        name: "gh",
+        description: "GitHub CLI for issues + PRs",
+        required: true,
+        installed: true,
+        version: ver || "unknown",
+        path: binPath,
+        authStatus: `Authenticated as ${login}`,
+    };
+}
+async function checkGithubIssues() {
+    const inGitRepo = findMainRepoRoot() !== null;
+    if (!(await ghCliAvailable())) {
+        return {
+            authenticated: false,
+            inGitRepo,
+            hint: "Install: brew install gh && gh auth login",
+        };
+    }
+    const login = await getGhUserLogin();
+    if (!login) {
+        return { authenticated: false, inGitRepo, hint: "Run: gh auth login" };
+    }
+    if (!inGitRepo) {
+        // Auth is fine; we're just not in a repo. Don't flag this as a failure.
+        return { authenticated: true, accountName: login, inGitRepo, repoName: null };
+    }
+    const repoName = await getRepoFullName();
+    return {
+        authenticated: true,
+        accountName: login,
+        repoName,
+        inGitRepo,
+        hint: !repoName
+            ? "Current repo is not on GitHub (gh repo view failed in this directory)"
+            : undefined,
+    };
+}
+function checkRemoteControl() {
+    const home = process.env["HOME"] || "";
+    const configPath = path.join(home, ".claude.json");
+    try {
+        if (fs.existsSync(configPath)) {
+            const content = fs.readFileSync(configPath, "utf-8");
+            const config = JSON.parse(content);
+            if (config.remoteControlAtStartup === true) {
+                return { enabled: true };
+            }
+        }
+    }
+    catch {
+        // JSON parse error or read error — fall through to disabled.
+    }
+    return {
+        enabled: false,
+        hint: 'Run /config in Claude Code and enable "Enable Remote Control for all sessions"',
+    };
+}
+function checkSessionSignalHooks() {
+    const home = process.env["HOME"] || "";
+    const settingsPath = path.join(home, ".claude", "settings.json");
+    const requiredEvents = ["Notification", "Stop", "UserPromptSubmit", "SessionEnd"];
+    const missing = [];
+    try {
+        if (!fs.existsSync(settingsPath)) {
+            return {
+                configured: false,
+                missingHooks: requiredEvents,
+                hint: "Run: mintree helpers session-signal install",
+            };
+        }
+        const settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+        const hooks = settings.hooks || {};
+        for (const event of requiredEvents) {
+            const eventHooks = hooks[event];
+            if (!Array.isArray(eventHooks)) {
+                missing.push(event);
+                continue;
+            }
+            const found = eventHooks.some((entry) => {
+                const inner = entry.hooks || [];
+                return inner.some(h => typeof h.command === "string" && h.command.includes("mintree helpers session-signal"));
+            });
+            if (!found)
+                missing.push(event);
+        }
+    }
+    catch {
+        return {
+            configured: false,
+            missingHooks: requiredEvents,
+            hint: "Could not parse ~/.claude/settings.json. Run: mintree helpers session-signal install",
+        };
+    }
+    if (missing.length === 0) {
+        return { configured: true, missingHooks: [] };
+    }
+    return {
+        configured: false,
+        missingHooks: missing,
+        hint: "Run: mintree helpers session-signal install",
+    };
+}
+function checkShellIntegration() {
+    const shellEnv = process.env["SHELL"] || "";
+    const shell = shellEnv.includes("zsh") ? "zsh" : shellEnv.includes("bash") ? "bash" : null;
+    const configured = process.env["MINTREE_SHELL_INTEGRATION"] === "1";
+    return { configured, shell };
+}
+function checkMintreeSetup() {
+    const root = findMainRepoRoot();
+    if (!root) {
+        return {
+            isGitRepo: false,
+            mintreeFolderExists: false,
+            metadataExists: false,
+            initShExists: false,
+            initShExecutable: false,
+            worktreesIgnored: false,
+            sessionStatesIgnored: false,
+            hints: ["Not in a git repository — run `git init` first, then `mintree init`."],
+        };
+    }
+    const mintreeDir = getMintreeDir(root);
+    const metadataPath = path.join(mintreeDir, "metadata.json");
+    const initShPath = getInitScriptPath(root);
+    const mintreeFolderExists = pathExists(mintreeDir);
+    const metadataExists = pathExists(metadataPath);
+    const initShExists = pathExists(initShPath);
+    const initShExecutable = initShExists && isExecutable(initShPath);
+    const worktreesIgnored = isGitIgnored(".mintree/worktrees", root);
+    const sessionStatesIgnored = isGitIgnored(".mintree/session-states", root);
+    const hints = [];
+    if (!mintreeFolderExists) {
+        hints.push("Run: mintree init");
+    }
+    else {
+        if (!metadataExists)
+            hints.push("Missing .mintree/metadata.json — run: mintree init");
+        if (!worktreesIgnored)
+            hints.push("Add `.mintree/worktrees/` to .gitignore");
+        if (!sessionStatesIgnored)
+            hints.push("Add `.mintree/session-states/` to .gitignore");
+        if (initShExists && !initShExecutable) {
+            hints.push(`Make init.sh executable: chmod +x ${initShPath}`);
+        }
+    }
+    return {
+        isGitRepo: true,
+        mainRepoRoot: root,
+        mintreeFolderExists,
+        metadataExists,
+        initShExists,
+        initShExecutable,
+        worktreesIgnored,
+        sessionStatesIgnored,
+        hints,
+    };
+}
+function StatusIcon({ ok, required }) {
+    if (ok)
+        return _jsx(Text, { color: "green", children: "\u2713" });
+    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] }), tool.path && _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] }) }))] }));
+}
+function GithubIssuesRow({ gh }) {
+    // Required only when we're inside a git repo. Outside one, the row is
+    // purely informational (auth check) so doctor can stay green when run
+    // from $HOME or any non-repo directory.
+    const required = gh.inGitRepo;
+    const ok = required ? gh.authenticated && !!gh.repoName : gh.authenticated;
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { children: [_jsx(StatusIcon, { ok: ok, required: required }), _jsx(Text, { children: " " }), _jsx(Text, { bold: true, children: "GitHub Issues" }), _jsx(Text, { dimColor: true, children: " - issue listing + PR ops" }), !required && _jsx(Text, { dimColor: true, children: " (no repo here)" })] }), _jsxs(Box, { marginLeft: 2, flexDirection: "column", children: [gh.authenticated ? (_jsxs(_Fragment, { children: [_jsxs(Text, { dimColor: true, children: ["User: ", gh.accountName] }), required && (_jsxs(Text, { dimColor: true, children: ["Repo: ", gh.repoName ?? "(not a GitHub repo)"] }))] })) : (_jsx(Text, { dimColor: true, children: "Not authenticated" })), gh.hint && _jsxs(Text, { color: "yellow", children: ["\u21B3 ", gh.hint] })] })] }));
+}
+function ShellRow({ status }) {
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { children: [_jsx(StatusIcon, { ok: status.configured, required: true }), _jsx(Text, { children: " " }), _jsx(Text, { bold: true, children: "Shell Integration" }), _jsx(Text, { dimColor: true, children: " - enables `cd` into worktrees" })] }), _jsx(Box, { marginLeft: 2, flexDirection: "column", children: status.configured ? (_jsxs(Text, { dimColor: true, children: ["Shell: ", status.shell ?? "unknown", " (MINTREE_SHELL_INTEGRATION=1)"] })) : status.shell ? (_jsx(Text, { color: "yellow", children: `↳ Add to ~/.${status.shell}rc: eval "$(mintree helpers shell-init ${status.shell})"` })) : (_jsx(Text, { color: "yellow", children: "\u21B3 Unsupported shell. mintree shell integration supports zsh and bash." })) })] }));
+}
+function RemoteControlRow({ status }) {
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { children: [_jsx(StatusIcon, { ok: status.enabled, required: false }), _jsx(Text, { children: " " }), _jsx(Text, { bold: true, children: "Remote Control" }), _jsx(Text, { dimColor: true, children: " - resume Claude sessions from any device" }), _jsx(Text, { dimColor: true, children: " (optional)" })] }), _jsxs(Box, { marginLeft: 2, flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: ["Enabled: ", status.enabled ? "yes" : "no"] }), status.hint && _jsxs(Text, { color: "yellow", children: ["\u21B3 ", status.hint] })] })] }));
+}
+function SessionSignalRow({ status }) {
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { children: [_jsx(StatusIcon, { ok: status.configured, required: false }), _jsx(Text, { children: " " }), _jsx(Text, { bold: true, children: "Session Signal Hooks" }), _jsx(Text, { dimColor: true, children: " - live session state for the dashboard" }), _jsx(Text, { dimColor: true, children: " (optional)" })] }), _jsxs(Box, { marginLeft: 2, flexDirection: "column", children: [status.configured ? (_jsx(Text, { dimColor: true, children: "All 4 hooks configured" })) : (_jsxs(Text, { dimColor: true, children: ["Missing: ", status.missingHooks.join(", ")] })), status.hint && _jsxs(Text, { color: "yellow", children: ["\u21B3 ", status.hint] })] })] }));
+}
+function MintreeSetupRow({ status }) {
+    if (!status.isGitRepo) {
+        return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { children: [_jsx(StatusIcon, { ok: false, required: false }), _jsx(Text, { children: " " }), _jsx(Text, { bold: true, children: "Repo Setup" }), _jsx(Text, { dimColor: true, children: " - .mintree/ configuration" }), _jsx(Text, { dimColor: true, children: " (optional)" })] }), _jsxs(Box, { marginLeft: 2, flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Not in a git repository" }), status.hints.map((h, i) => (_jsxs(Text, { color: "yellow", children: ["\u21B3 ", h] }, i)))] })] }));
+    }
+    const ok = status.mintreeFolderExists &&
+        status.metadataExists &&
+        status.worktreesIgnored &&
+        status.sessionStatesIgnored &&
+        (!status.initShExists || status.initShExecutable);
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { children: [_jsx(StatusIcon, { ok: ok, required: false }), _jsx(Text, { children: " " }), _jsx(Text, { bold: true, children: "Repo Setup" }), _jsx(Text, { dimColor: true, children: " - .mintree/ configuration" }), _jsx(Text, { dimColor: true, children: " (optional)" })] }), _jsxs(Box, { marginLeft: 2, flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: ["Main repo: ", status.mainRepoRoot] }), _jsxs(Text, { dimColor: true, children: [".mintree/: ", status.mintreeFolderExists ? "exists" : "missing"] }), status.mintreeFolderExists && (_jsxs(_Fragment, { children: [_jsxs(Text, { dimColor: true, children: ["metadata.json: ", status.metadataExists ? "exists" : "missing"] }), _jsxs(Text, { dimColor: true, children: ["init.sh:", " ", status.initShExists
+                                        ? status.initShExecutable
+                                            ? "executable"
+                                            : "not executable"
+                                        : "not present (optional)"] }), _jsxs(Text, { dimColor: true, children: [".mintree/worktrees ignored: ", status.worktreesIgnored ? "yes" : "no"] }), _jsxs(Text, { dimColor: true, children: [".mintree/session-states ignored: ", status.sessionStatesIgnored ? "yes" : "no"] })] })), status.hints.map((h, i) => (_jsxs(Text, { color: "yellow", children: ["\u21B3 ", h] }, i)))] })] }));
+}
+export default function Doctor() {
+    const [tools, setTools] = useState(null);
+    const [gh, setGh] = useState(null);
+    const [rc, setRc] = useState(null);
+    const [hooks, setHooks] = useState(null);
+    const [setup, setSetup] = useState(null);
+    const [shell, setShell] = useState(null);
+    useEffect(() => {
+        (async () => {
+            const toolResults = await Promise.all([
+                checkTool("git", "Version control", true, "git --version | head -1", "Install: brew install git"),
+                checkGh(),
+                checkClaude(),
+                checkTool("tmux", "Open worktrees in separate windows", false, "tmux -V", "Install: brew install tmux"),
+            ]);
+            const mintreeRow = {
+                name: "mintree",
+                description: "this CLI",
+                required: true,
+                installed: true,
+                version,
+            };
+            toolResults.unshift(mintreeRow);
+            const nodeRow = {
+                name: "node",
+                description: "Node.js runtime (≥ 20)",
+                required: true,
+                installed: true,
+                version: process.version,
+            };
+            toolResults.unshift(nodeRow);
+            const ghRes = await checkGithubIssues();
+            setTools(toolResults);
+            setGh(ghRes);
+            setRc(checkRemoteControl());
+            setHooks(checkSessionSignalHooks());
+            setSetup(checkMintreeSetup());
+            setShell(checkShellIntegration());
+        })();
+    }, []);
+    const loading = !tools || !gh || !rc || !hooks || !setup || !shell;
+    if (loading) {
+        return (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { children: " Checking system requirements..." })] }));
+    }
+    const requiredMissing = tools.filter(t => t.required && (!t.installed || t.hint));
+    const optionalMissing = tools.filter(t => !t.required && !t.installed);
+    // GitHub Issues only counts toward the required tally when we're inside a
+    // git repo; otherwise the auth-only check is purely informational.
+    const ghOk = gh.inGitRepo ? gh.authenticated && !!gh.repoName : true;
+    const shellOk = shell.configured;
+    const allRequired = requiredMissing.length === 0 && ghOk && shellOk;
+    const requiredFailing = requiredMissing.length + (ghOk ? 0 : 1) + (shellOk ? 0 : 1);
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "Mintree Doctor" }), _jsxs(Text, { dimColor: true, children: [" v", version] })] }), _jsx(Box, { marginBottom: 1, flexDirection: "column", children: _jsx(Text, { bold: true, underline: true, children: "CLI Tools" }) }), tools.map(t => (_jsx(ToolRow, { tool: t }, t.name))), _jsx(Box, { marginBottom: 1, marginTop: 1, flexDirection: "column", children: _jsx(Text, { bold: true, underline: true, children: "Integrations" }) }), _jsx(GithubIssuesRow, { gh: gh }), _jsx(ShellRow, { status: shell }), _jsx(MintreeSetupRow, { status: setup }), _jsx(Box, { marginBottom: 1, marginTop: 1, flexDirection: "column", children: _jsx(Text, { bold: true, underline: true, children: "Claude Code" }) }), _jsx(RemoteControlRow, { status: rc }), _jsx(SessionSignalRow, { status: hooks }), _jsx(Box, { marginTop: 1, borderStyle: "single", borderColor: allRequired ? "green" : "yellow", paddingX: 2, children: allRequired ? (_jsx(Text, { color: "green", children: "All required checks pass. mintree is ready to use." })) : (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "yellow", children: [requiredFailing, " required item(s) need attention"] }), optionalMissing.length > 0 && (_jsxs(Text, { dimColor: true, children: [optionalMissing.length, " optional item(s) not installed"] }))] })) })] }));
+}

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

@@ -0,0 +1 @@
+export declare const description = "Helpers for shell integration and Claude Code hooks";

package/dist/commands/helpers/index.js

@@ -0,0 +1 @@
+export const description = "Helpers for shell integration and Claude Code hooks";

package/dist/commands/helpers/session-signal/end.d.ts

@@ -0,0 +1,2 @@
+export declare const description = "Hook handler for Claude's SessionEnd event (writes state=exited)";
+export default function End(): null;

package/dist/commands/helpers/session-signal/end.js

@@ -0,0 +1,9 @@
+import { useEffect } from "react";
+import { signalState } from "../../../lib/session-signal.js";
+export const description = "Hook handler for Claude's SessionEnd event (writes state=exited)";
+export default function End() {
+    useEffect(() => {
+        signalState("exited");
+    }, []);
+    return null;
+}

package/dist/commands/helpers/session-signal/index.d.ts

@@ -0,0 +1 @@
+export declare const description = "Install Claude Code hooks and write session state files";

package/dist/commands/helpers/session-signal/index.js

@@ -0,0 +1 @@
+export const description = "Install Claude Code hooks and write session state files";

package/dist/commands/helpers/session-signal/install.d.ts

@@ -0,0 +1,2 @@
+export declare const description = "Install the four mintree hooks in ~/.claude/settings.json";
+export default function Install(): import("react/jsx-runtime").JSX.Element | null;

package/dist/commands/helpers/session-signal/install.js

@@ -0,0 +1,25 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Box, Text } from "ink";
+import { installHooks } from "../../../lib/session-signal.js";
+export const description = "Install the four mintree hooks in ~/.claude/settings.json";
+export default function Install() {
+    const [result, setResult] = useState(null);
+    useEffect(() => {
+        setTimeout(() => {
+            try {
+                const { settingsPath, created } = installHooks();
+                setResult({ ok: true, settingsPath, created });
+            }
+            catch (err) {
+                setResult({ ok: false, message: err instanceof Error ? err.message : String(err) });
+            }
+        }, 0);
+    }, []);
+    if (!result)
+        return null;
+    if (!result.ok) {
+        return (_jsx(Box, { padding: 1, children: _jsxs(Text, { color: "red", bold: true, children: ["\u2717 ", result.message] }) }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "cyan", children: "mintree helpers session-signal install" }) }), _jsxs(Text, { children: [_jsx(Text, { color: "green", children: "\u2713" }), " ", result.created ? "created" : "updated", " ", _jsx(Text, { dimColor: true, children: result.settingsPath })] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Hooks installed: UserPromptSubmit, Stop, SessionEnd, Notification." }), _jsx(Text, { dimColor: true, children: "Re-run safely \u2014 existing mintree entries are replaced; non-mintree hooks are preserved." })] })] }));
+}

package/dist/commands/helpers/session-signal/notification.d.ts

@@ -0,0 +1,2 @@
+export declare const description = "Hook handler for Claude's Notification event (writes state=waiting)";
+export default function Notification(): null;

package/dist/commands/helpers/session-signal/notification.js

@@ -0,0 +1,9 @@
+import { useEffect } from "react";
+import { signalState } from "../../../lib/session-signal.js";
+export const description = "Hook handler for Claude's Notification event (writes state=waiting)";
+export default function Notification() {
+    useEffect(() => {
+        signalState("waiting");
+    }, []);
+    return null;
+}

package/dist/commands/helpers/session-signal/prompt.d.ts

@@ -0,0 +1,2 @@
+export declare const description = "Hook handler for Claude's UserPromptSubmit event (writes state=active)";
+export default function Prompt(): null;

package/dist/commands/helpers/session-signal/prompt.js

@@ -0,0 +1,9 @@
+import { useEffect } from "react";
+import { signalState } from "../../../lib/session-signal.js";
+export const description = "Hook handler for Claude's UserPromptSubmit event (writes state=active)";
+export default function Prompt() {
+    useEffect(() => {
+        signalState("active");
+    }, []);
+    return null;
+}

package/dist/commands/helpers/session-signal/stop.d.ts

@@ -0,0 +1,2 @@
+export declare const description = "Hook handler for Claude's Stop event (writes state=idle)";
+export default function Stop(): null;

package/dist/commands/helpers/session-signal/stop.js

@@ -0,0 +1,9 @@
+import { useEffect } from "react";
+import { signalState } from "../../../lib/session-signal.js";
+export const description = "Hook handler for Claude's Stop event (writes state=idle)";
+export default function Stop() {
+    useEffect(() => {
+        signalState("idle");
+    }, []);
+    return null;
+}

package/dist/commands/helpers/shell-init.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export declare const description = "Output shell integration script (eval in your shell rc)";
+export declare const args: z.ZodTuple<[z.ZodDefault<z.ZodEnum<{
+    zsh: "zsh";
+    bash: "bash";
+}>>], null>;
+type Props = {
+    args: z.infer<typeof args>;
+};
+export default function ShellInit({ args }: Props): null;
+export {};

package/dist/commands/helpers/shell-init.js

@@ -0,0 +1,111 @@
+import { useEffect } from "react";
+import { argument } from "pastel";
+import { z } from "zod";
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// At build time this file lives at dist/commands/helpers/shell-init.js — the
+// shell templates ship at <pkg>/shell/. Three levels up from __dirname.
+const shellDir = path.resolve(__dirname, "..", "..", "..", "shell");
+export const description = "Output shell integration script (eval in your shell rc)";
+export const args = z.tuple([
+    z
+        .enum(["zsh", "bash"])
+        .default("zsh")
+        .describe(argument({
+        name: "shell",
+        description: "Target shell: zsh (default) or bash",
+    })),
+]);
+/**
+ * Wraps the integration body in a bootstrap that:
+ *  1. Computes a per-shell cache path under XDG_CACHE_HOME/mintree/.
+ *  2. Writes the body verbatim to that cache file (using a heredoc so the
+ *     body is parsed by the cache, not by this bootstrap).
+ *  3. Sources the cache so this shell gets the integration immediately.
+ *
+ * The cache file starts with a self-validation guard: if the `mintree`
+ * binary on $PATH is newer than the cache, it re-runs the bootstrap so the
+ * cache regenerates after an update. Subsequent shells can skip the bootstrap
+ * entirely — see the .rc one-liner in the comment header.
+ */
+function buildBootstrap(shell, body) {
+    const cachePath = shell === "zsh"
+        ? `\${MINTREE_CACHE_DIR:-\${XDG_CACHE_HOME:-$HOME/.cache}/mintree}/init-zsh.zsh`
+        : `\${MINTREE_CACHE_DIR:-\${XDG_CACHE_HOME:-$HOME/.cache}/mintree}/init-bash.bash`;
+    const mkdirParent = shell === "zsh" ? `mkdir -p "\${_mintree_cache:h}"` : `mkdir -p "$(dirname "$_mintree_cache")"`;
+    // `${(%):-%x}` in zsh is the script path of the file being sourced. In
+    // bash that's `${BASH_SOURCE[0]}`. We use it to compare against the
+    // `mintree` binary's mtime (`-nt`) — when mintree is newer, the cache
+    // is stale and we regenerate.
+    const sourcePathExpansion = shell === "zsh" ? `\${(%):-%x}` : `\${BASH_SOURCE[0]}`;
+    const commandLookup = shell === "zsh" ? `\${commands[mintree]:-}` : `$(command -v mintree)`;
+    const headerComment = shell === "zsh"
+        ? `# mintree shell integration bootstrap (zsh) — self-caching
+#
+# Caches the integration body in \${XDG_CACHE_HOME:-~/.cache}/mintree/init-zsh.zsh
+# on first run so subsequent shells can source it without spawning node.
+# After upgrading mintree the cache self-invalidates by mtime.
+#
+# .zshrc one-liner with first-run fallback:
+#   _SI=\${XDG_CACHE_HOME:-$HOME/.cache}/mintree/init-zsh.zsh
+#   [[ -f $_SI ]] && source $_SI || eval "$(mintree helpers shell-init zsh)"`
+        : `# mintree shell integration bootstrap (bash) — self-caching
+#
+# Caches the integration body in \${XDG_CACHE_HOME:-~/.cache}/mintree/init-bash.bash
+# on first run so subsequent shells can source it without spawning node.
+# After upgrading mintree the cache self-invalidates by mtime.
+#
+# .bashrc one-liner with first-run fallback:
+#   _SI=\${XDG_CACHE_HOME:-$HOME/.cache}/mintree/init-bash.bash
+#   [[ -f "$_SI" ]] && source "$_SI" || eval "$(mintree helpers shell-init bash)"`;
+    // Trailing-newline-stripped body — we add our own newline structure.
+    const trimmedBody = body.endsWith("\n") ? body.slice(0, -1) : body;
+    return `${headerComment}
+
+_mintree_cache="${cachePath}"
+${mkdirParent}
+
+# Single-quoted heredoc delimiter so $vars and \`commands\` in the body
+# aren't expanded here — they're only evaluated when the cache file is
+# sourced.
+cat > "$_mintree_cache" <<'MINTREE_INIT_BODY_EOF__'
+# AUTO-GENERATED CACHE — do not edit. Regenerate with:
+#   eval "$(mintree helpers shell-init ${shell})"
+
+# Self-validation: when the mintree binary is newer than this cache,
+# re-run the bootstrap so the body refreshes, then return so the (now
+# stale) definitions below aren't re-loaded into the shell.
+if [[ ${commandLookup} -nt ${sourcePathExpansion} ]]; then
+    eval "$(command mintree helpers shell-init ${shell})"
+    return
+fi
+
+${trimmedBody}
+MINTREE_INIT_BODY_EOF__
+
+# Source the cache we just wrote so this shell gets the integration now.
+source "$_mintree_cache"
+unset _mintree_cache
+`;
+}
+export default function ShellInit({ args }) {
+    const [shell] = args;
+    useEffect(() => {
+        const filePath = path.join(shellDir, `init.${shell}`);
+        try {
+            const body = fs.readFileSync(filePath, "utf-8");
+            const bootstrap = buildBootstrap(shell, body);
+            process.stdout.write(bootstrap);
+            process.exit(0);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`mintree: failed to read ${filePath}: ${message}\n`);
+            process.exit(1);
+        }
+    }, [shell]);
+    return null;
+}

package/dist/commands/index.d.ts

@@ -0,0 +1,2 @@
+export declare const description = "Show welcome screen (TUI dashboard lands in Phase 4)";
+export default function Index(): import("react/jsx-runtime").JSX.Element;

package/dist/commands/index.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+export const description = "Show welcome screen (TUI dashboard lands in Phase 4)";
+export default function Index() {
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsx(Text, { bold: true, color: "green", children: "mintree" }), _jsx(Text, { dimColor: true, children: "Issue-driven worktrees + Claude Code sessions." }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: ["Run ", _jsx(Text, { bold: true, children: "mintree --help" }), " to list available commands."] }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Phase 0 scaffolding \u00B7 `doctor`, `init` and `worktree` commands land in subsequent phases." }) })] }));
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,2 @@
+export declare const description = "Initialize the current repo for mintree (creates .mintree/, updates .gitignore)";
+export default function Init(): import("react/jsx-runtime").JSX.Element;