santree 0.7.4 → 0.7.5

package/dist/lib/setup/steps.js

@@ -0,0 +1,328 @@
+import * as fs from "fs";
+import { run } from "../exec.js";
+import { findMainRepoRoot, getSantreeDir, getInitScriptPath } from "../git.js";
+import { isRepoTrackerConfigured } from "../trackers/index.js";
+import { getMultiplexer } from "../multiplexer/index.js";
+import { resolveClaudeBinary } from "../ai.js";
+import { CLAUDE_CODE_PACKAGE, detectPackageManager, getInstallCommandFor } from "../version.js";
+import { installHooks as installSessionSignalHooks } from "../session-signal.js";
+import { isStatuslineConfigured, configureStatusline, isRemoteControlEnabled, enableRemoteControl, isSessionSignalConfigured, } from "../claude-config.js";
+import { resolveShellConfig, upsertManagedLine, isEnvVarSet, envKey, } from "./shell-config.js";
+import { detectDiffPagers, detectEditors, getInstaller, which } from "./tools.js";
+import { missingIgnoreEntries, addIgnoreEntries, SANTREE_IGNORE_ENTRIES, } from "./gitignore.js";
+import { spawnTTY, santreeSelfArgv } from "./apply.js";
+export function buildContext(dryRun) {
+    return {
+        repoRoot: findMainRepoRoot(),
+        shell: resolveShellConfig(),
+        dryRun,
+    };
+}
+/**
+ * Build the full step catalog with `detect` + `options` resolved against the
+ * current machine. The wizard filters to `actionable` steps for the checklist.
+ */
+export function buildSteps(ctx) {
+    const steps = [];
+    const { shell, repoRoot, dryRun } = ctx;
+    const installer = getInstaller();
+    // ── Editor (SANTREE_EDITOR) ─────────────────────────────────────────────────
+    {
+        const editors = detectEditors();
+        const set = isEnvVarSet("SANTREE_EDITOR", shell);
+        const detect = set ? "ok" : editors.length > 0 ? "actionable" : "unavailable";
+        steps.push({
+            id: "editor",
+            title: "Default editor (SANTREE_EDITOR)",
+            detail: "Editor opened by the dashboard's [e] action",
+            scope: "global",
+            kind: "file",
+            recommended: true,
+            detect,
+            options: editors.map((e) => ({ value: e.command, label: e.command })),
+            optionPrompt: "Pick your editor:",
+            apply: (choice) => {
+                const editor = choice || editors[0]?.command || "vim";
+                if (dryRun)
+                    return { ok: true, message: `Would set SANTREE_EDITOR=${editor}` };
+                upsertManagedLine(shell.rcPath, envKey("SANTREE_EDITOR"), `export SANTREE_EDITOR="${editor}"`);
+                return { ok: true, message: `Set SANTREE_EDITOR=${editor} in ${shell.rcPath}` };
+            },
+        });
+    }
+    // ── Diff tool (SANTREE_DIFF_TOOL) ───────────────────────────────────────────
+    {
+        const pagers = detectDiffPagers();
+        const hasDelta = pagers.some((p) => p.command === "delta");
+        const options = pagers.map((p) => ({ value: p.command, label: p.command }));
+        if (installer && !hasDelta) {
+            options.push({
+                value: "install:delta",
+                label: `git-delta — install via ${installer.name}`,
+            });
+        }
+        const set = isEnvVarSet("SANTREE_DIFF_TOOL", shell);
+        const detect = set ? "ok" : options.length > 0 ? "actionable" : "unavailable";
+        steps.push({
+            id: "diff-tool",
+            title: "Diff tool (SANTREE_DIFF_TOOL)",
+            detail: "Pretty diffs in `worktree diff` and the dashboard [v] overlay",
+            scope: "global",
+            kind: installer && !hasDelta ? "spawn" : "file",
+            recommended: true,
+            detect,
+            options,
+            optionPrompt: "Pick a diff pager:",
+            apply: (choice) => {
+                const pick = choice || options[0]?.value;
+                if (!pick)
+                    return { ok: false, message: "No diff pager available" };
+                let tool = pick;
+                if (pick.startsWith("install:")) {
+                    tool = pick.slice("install:".length);
+                    if (dryRun) {
+                        return {
+                            ok: true,
+                            message: `Would ${installer.installArgv("git-delta").join(" ")} then set SANTREE_DIFF_TOOL=${tool}`,
+                        };
+                    }
+                    const argv = installer.installArgv("git-delta");
+                    const code = spawnTTY(argv[0], argv.slice(1));
+                    if (code !== 0)
+                        return { ok: false, message: "git-delta install failed — SANTREE_DIFF_TOOL not set" };
+                }
+                if (dryRun)
+                    return { ok: true, message: `Would set SANTREE_DIFF_TOOL=${tool}` };
+                upsertManagedLine(shell.rcPath, envKey("SANTREE_DIFF_TOOL"), `export SANTREE_DIFF_TOOL="${tool}"`);
+                return { ok: true, message: `Set SANTREE_DIFF_TOOL=${tool} in ${shell.rcPath}` };
+            },
+        });
+    }
+    // ── Statusline ──────────────────────────────────────────────────────────────
+    steps.push({
+        id: "statusline",
+        title: "Claude Code statusline",
+        detail: "Worktree-aware statusline (branch, context usage, session state)",
+        scope: "global",
+        kind: "file",
+        recommended: true,
+        detect: isStatuslineConfigured() ? "ok" : "actionable",
+        apply: () => {
+            if (dryRun)
+                return { ok: true, message: "Would configure statusLine in ~/.claude/settings.json" };
+            const p = configureStatusline();
+            return { ok: true, message: `Configured statusline in ${p}` };
+        },
+    });
+    // ── Session-signal hooks ────────────────────────────────────────────────────
+    steps.push({
+        id: "session-signal",
+        title: "Session-state signal hooks",
+        detail: "Surface Claude session state (waiting/active/idle) in the dashboard",
+        scope: "global",
+        kind: "file",
+        recommended: true,
+        detect: isSessionSignalConfigured() ? "ok" : "actionable",
+        apply: () => {
+            if (dryRun)
+                return {
+                    ok: true,
+                    message: "Would install session-signal hooks in ~/.claude/settings.json",
+                };
+            const p = installSessionSignalHooks();
+            return { ok: true, message: `Installed session-signal hooks in ${p}` };
+        },
+    });
+    // ── Remote control ──────────────────────────────────────────────────────────
+    steps.push({
+        id: "remote-control",
+        title: "Claude Code remote control",
+        detail: "Enable remote control at startup (drive sessions from the dashboard)",
+        scope: "global",
+        kind: "file",
+        recommended: false,
+        detect: isRemoteControlEnabled() ? "ok" : "actionable",
+        apply: () => {
+            if (dryRun)
+                return { ok: true, message: "Would set remoteControlAtStartup in ~/.claude.json" };
+            const p = enableRemoteControl();
+            return { ok: true, message: `Enabled remote control in ${p}` };
+        },
+    });
+    // ── GitHub CLI install + auth ───────────────────────────────────────────────
+    {
+        const ghInstalled = !!which("gh");
+        // `gh auth status` prints to stderr — redirect so it doesn't leak into the wizard.
+        const ghAuthed = ghInstalled && run("gh auth status >/dev/null 2>&1") !== null;
+        const detect = ghAuthed
+            ? "ok"
+            : ghInstalled || installer
+                ? "actionable"
+                : "unavailable";
+        steps.push({
+            id: "gh",
+            title: "GitHub CLI (gh) auth",
+            detail: "Required for PR create / review / checks",
+            scope: "global",
+            kind: "spawn",
+            recommended: true,
+            detect,
+            apply: () => {
+                if (dryRun) {
+                    const parts = !ghInstalled && installer ? `${installer.installArgv("gh").join(" ")} then ` : "";
+                    return { ok: true, message: `Would ${parts}gh auth login` };
+                }
+                if (!ghInstalled) {
+                    if (!installer)
+                        return { ok: false, message: "Install gh manually: see https://cli.github.com" };
+                    const argv = installer.installArgv("gh");
+                    const code = spawnTTY(argv[0], argv.slice(1));
+                    if (code !== 0)
+                        return { ok: false, message: "gh install failed" };
+                }
+                const code = spawnTTY("gh", ["auth", "login"]);
+                return code === 0
+                    ? { ok: true, message: "gh authenticated" }
+                    : { ok: false, message: "gh auth login did not complete" };
+            },
+        });
+    }
+    // ── Claude Code CLI ─────────────────────────────────────────────────────────
+    {
+        const installed = !!resolveClaudeBinary();
+        steps.push({
+            id: "claude",
+            title: "Claude Code CLI",
+            detail: "Powers `worktree work`, `pr fix`, `pr review`",
+            scope: "global",
+            kind: "spawn",
+            recommended: true,
+            detect: installed ? "ok" : "actionable",
+            apply: () => {
+                const cmd = getInstallCommandFor(detectPackageManager(), CLAUDE_CODE_PACKAGE);
+                if (dryRun)
+                    return { ok: true, message: `Would run: ${cmd.display}` };
+                const code = spawnTTY(cmd.cmd, cmd.args);
+                return code === 0
+                    ? { ok: true, message: "Claude Code CLI installed" }
+                    : { ok: false, message: `Install failed — run manually: ${cmd.display}` };
+            },
+        });
+    }
+    // ── tmux (multiplexer) ──────────────────────────────────────────────────────
+    {
+        const active = getMultiplexer().kind !== "none";
+        const detect = active ? "ok" : installer ? "actionable" : "unavailable";
+        steps.push({
+            id: "tmux",
+            title: "tmux (terminal multiplexer)",
+            detail: "Enables new-window flows: work / fix / review / investigate",
+            scope: "global",
+            kind: "spawn",
+            recommended: false,
+            detect,
+            apply: () => {
+                if (!installer)
+                    return { ok: false, message: "Install tmux manually: brew install tmux" };
+                if (dryRun)
+                    return { ok: true, message: `Would ${installer.installArgv("tmux").join(" ")}` };
+                const argv = installer.installArgv("tmux");
+                const code = spawnTTY(argv[0], argv.slice(1));
+                return code === 0
+                    ? { ok: true, message: "tmux installed (start a tmux session to use new-window flows)" }
+                    : { ok: false, message: "tmux install failed" };
+            },
+        });
+    }
+    // ── Repo-scoped steps ───────────────────────────────────────────────────────
+    if (repoRoot) {
+        const santreeDir = getSantreeDir(repoRoot);
+        const initSh = getInitScriptPath(repoRoot);
+        // .santree scaffold
+        {
+            const folderOk = fs.existsSync(santreeDir);
+            const initOk = fs.existsSync(initSh);
+            let execOk = false;
+            if (initOk) {
+                try {
+                    fs.accessSync(initSh, fs.constants.X_OK);
+                    execOk = true;
+                }
+                catch { }
+            }
+            steps.push({
+                id: "scaffold",
+                title: ".santree scaffold",
+                detail: "Create .santree/ and an executable init.sh (runs on worktree create)",
+                scope: "repo",
+                kind: "file",
+                recommended: true,
+                detect: folderOk && initOk && execOk ? "ok" : "actionable",
+                apply: () => {
+                    if (dryRun)
+                        return { ok: true, message: `Would create ${santreeDir} and an executable init.sh` };
+                    fs.mkdirSync(santreeDir, { recursive: true });
+                    if (!fs.existsSync(initSh)) {
+                        fs.writeFileSync(initSh, "#!/usr/bin/env bash\n# Runs after `santree worktree create`. Add setup steps here.\n");
+                    }
+                    fs.chmodSync(initSh, 0o755);
+                    return { ok: true, message: `Scaffolded ${santreeDir}` };
+                },
+            });
+        }
+        // Ignore santree files
+        {
+            const missing = missingIgnoreEntries(repoRoot);
+            steps.push({
+                id: "gitignore",
+                title: "Ignore santree's machine files",
+                detail: `Ignore ${SANTREE_IGNORE_ENTRIES.join(", ")} (keeps .santree/issues/ tracked)`,
+                scope: "repo",
+                kind: "file",
+                recommended: true,
+                detect: missing.length === 0 ? "ok" : "actionable",
+                options: [
+                    { value: "gitignore", label: ".gitignore — shared with your team" },
+                    { value: "exclude", label: ".git/info/exclude — local to your clone" },
+                ],
+                optionPrompt: "Where should the ignore rules go?",
+                apply: (choice) => {
+                    const target = (choice === "exclude" ? "exclude" : "gitignore");
+                    const where = target === "exclude" ? ".git/info/exclude" : ".gitignore";
+                    if (dryRun)
+                        return {
+                            ok: true,
+                            message: `Would add ${missing.length} entr${missing.length === 1 ? "y" : "ies"} to ${where}`,
+                        };
+                    const added = addIgnoreEntries(repoRoot, target);
+                    return {
+                        ok: true,
+                        message: `Added ${added.length} entr${added.length === 1 ? "y" : "ies"} to ${where}`,
+                    };
+                },
+            });
+        }
+        // Issue tracker
+        {
+            steps.push({
+                id: "tracker",
+                title: "Issue tracker",
+                detail: "Pick + authenticate Linear / GitHub / Local for this repo",
+                scope: "repo",
+                kind: "spawn",
+                recommended: true,
+                detect: isRepoTrackerConfigured(repoRoot) ? "ok" : "actionable",
+                apply: () => {
+                    if (dryRun)
+                        return { ok: true, message: "Would run: santree issue setup" };
+                    const { cmd, args } = santreeSelfArgv(["issue", "setup"]);
+                    const code = spawnTTY(cmd, args, { cwd: repoRoot });
+                    return code === 0
+                        ? { ok: true, message: "Issue tracker configured" }
+                        : { ok: false, message: "Tracker setup did not complete" };
+                },
+            });
+        }
+    }
+    return steps;
+}

package/dist/lib/setup/tools.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Tool detection + installation for `santree setup`.
+ *
+ * macOS (Homebrew) is the only auto-install path today. The `PlatformInstaller`
+ * seam keeps the door open for apt/dnf/etc. without touching call sites — add a
+ * resolver branch in `getInstaller()` and the steps keep working.
+ */
+export declare function isMacOS(): boolean;
+/** Resolve a command on PATH, or null if absent. */
+export declare function which(cmd: string): string | null;
+export interface DetectedTool {
+    command: string;
+    path: string;
+}
+export declare function detectDiffPagers(): DetectedTool[];
+export declare function detectEditors(): DetectedTool[];
+export interface PlatformInstaller {
+    /** Human label, e.g. "Homebrew". */
+    name: string;
+    /** argv for installing `pkg` (cmd + args), suitable for a TTY spawn. */
+    installArgv(pkg: string): string[];
+}
+export declare function getInstaller(): PlatformInstaller | null;

package/dist/lib/setup/tools.js

@@ -0,0 +1,47 @@
+import * as os from "os";
+import { run } from "../exec.js";
+/**
+ * Tool detection + installation for `santree setup`.
+ *
+ * macOS (Homebrew) is the only auto-install path today. The `PlatformInstaller`
+ * seam keeps the door open for apt/dnf/etc. without touching call sites — add a
+ * resolver branch in `getInstaller()` and the steps keep working.
+ */
+export function isMacOS() {
+    return os.platform() === "darwin";
+}
+/** Resolve a command on PATH, or null if absent. */
+export function which(cmd) {
+    return run(`which ${cmd}`);
+}
+/** Known unified-diff pagers, best first. The first one on PATH wins. */
+const DIFF_PAGERS = ["delta", "diff-so-fancy", "diff-highlight", "ydiff", "riff"];
+export function detectDiffPagers() {
+    const found = [];
+    for (const cmd of DIFF_PAGERS) {
+        const p = which(cmd);
+        if (p)
+            found.push({ command: cmd, path: p });
+    }
+    return found;
+}
+/** Editors we know how to launch, in rough order of popularity. */
+const KNOWN_EDITORS = ["code", "cursor", "zed", "subl", "windsurf", "nvim", "vim", "nano", "emacs"];
+export function detectEditors() {
+    const found = [];
+    for (const cmd of KNOWN_EDITORS) {
+        const p = which(cmd);
+        if (p)
+            found.push({ command: cmd, path: p });
+    }
+    return found;
+}
+export function getInstaller() {
+    if (isMacOS() && which("brew")) {
+        return {
+            name: "Homebrew",
+            installArgv: (pkg) => ["brew", "install", pkg],
+        };
+    }
+    return null;
+}

package/dist/lib/squirrel-loader.d.ts

@@ -1,9 +1,11 @@
 interface Props {
     text?: string;
+    /** Optional version line (e.g. santree's running version), shown under `text`. */
+    version?: string;
 }
 /** Animated 3D squirrel for loading states. SDF ray-marched at module
  * load with surface-normal lighting, soft shadows, AO, and a rainbow
  * Y-gradient. Body spin + tail wag + breathing/sniff/ear-flick layers
  * combine over independent phases. */
-export default function SquirrelLoader({ text }: Props): import("react/jsx-runtime").JSX.Element;
+export default function SquirrelLoader({ text, version }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/lib/squirrel-loader.js

@@ -292,7 +292,7 @@ function colorForCell(y, lit) {
  * load with surface-normal lighting, soft shadows, AO, and a rainbow
  * Y-gradient. Body spin + tail wag + breathing/sniff/ear-flick layers
  * combine over independent phases. */
-export default function SquirrelLoader({ text }) {
+export default function SquirrelLoader({ text, version }) {
     const [frame, setFrame] = useState(0);
     useEffect(() => {
         const id = setInterval(() => setFrame((f) => (f + 1) % FRAMES.length), FRAME_MS);
@@ -318,5 +318,5 @@ export default function SquirrelLoader({ text }) {
             return spans;
         });
     }, [frame]);
-    return (_jsxs(Box, { flexDirection: "column", alignItems: "center", children: [rows.map((spans, i) => (_jsx(Box, { children: _jsx(Text, { children: spans.map((s, j) => (_jsx(Text, { color: s.color, children: s.text }, j))) }) }, i))), text && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: text }) }))] }));
+    return (_jsxs(Box, { flexDirection: "column", alignItems: "center", children: [rows.map((spans, i) => (_jsx(Box, { children: _jsx(Text, { children: spans.map((s, j) => (_jsx(Text, { color: s.color, children: s.text }, j))) }) }, i))), text && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: text }) })), version && (_jsx(Box, { children: _jsxs(Text, { dimColor: true, children: ["v", version] }) }))] }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "santree",
-	"version": "0.7.4",
+	"version": "0.7.5",
 	"description": "Git worktree manager",
 	"license": "MIT",
 	"author": "Santiago Toscanini",
@@ -40,7 +40,6 @@
 	},
 	"files": [
 		"dist",
-		"shell",
 		"prompts"
 	],
 	"dependencies": {

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

@@ -1,11 +0,0 @@
-import { z } from "zod/v4";
-export declare const description = "Output shell integration script";
-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

@@ -1,122 +0,0 @@
-import { useEffect, useState, useRef } from "react";
-import { argument } from "pastel";
-import { z } from "zod/v4";
-import { readdirSync, statSync, existsSync } from "fs";
-import { fileURLToPath } from "url";
-import { dirname, join } from "path";
-import nunjucks from "nunjucks";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-export const description = "Output shell integration script";
-export const args = z.tuple([
-    z
-        .enum(["zsh", "bash"])
-        .default("zsh")
-        .describe(argument({ name: "shell", description: "Shell type (zsh or bash)" })),
-]);
-const ARG_COMPLETIONS = {};
-function extractOptions(mod) {
-    const options = [];
-    if (mod.options) {
-        const shape = mod.options.shape ?? {};
-        for (const [key, value] of Object.entries(shape)) {
-            const schema = value;
-            const desc = schema.description ?? schema._zod?.def?.description ?? "";
-            options.push({
-                name: key,
-                description: desc,
-                completion: key === "base" ? "all_branches" : null,
-            });
-        }
-    }
-    return options;
-}
-/**
- * Dynamically loads command modules and extracts their metadata.
- * Handles both top-level files and directory-based command groups.
- */
-async function getCommands() {
-    const commandsDir = join(__dirname, "..");
-    const entries = readdirSync(commandsDir);
-    const commands = [];
-    for (const entry of entries) {
-        const entryPath = join(commandsDir, entry);
-        const stat = statSync(entryPath);
-        if (stat.isDirectory()) {
-            // Directory-based command group — complete arg to subcommand names
-            const subFiles = readdirSync(entryPath).filter((f) => f.endsWith(".js") && f !== "index.js");
-            const subNames = subFiles.map((f) => f.replace(".js", ""));
-            if (subNames.length === 0)
-                continue;
-            let description = "";
-            const indexPath = join(entryPath, "index.js");
-            if (existsSync(indexPath)) {
-                try {
-                    const indexMod = await import(indexPath);
-                    description = indexMod.description ?? "";
-                }
-                catch {
-                    // no description
-                }
-            }
-            commands.push({
-                name: entry,
-                funcName: entry.replace(/-/g, "_"),
-                description,
-                hasArgs: true,
-                argCompletion: "static",
-                argCompletionValues: subNames.join(" "),
-                options: [],
-            });
-            continue;
-        }
-        if (!entry.endsWith(".js"))
-            continue;
-        const name = entry.replace(".js", "");
-        try {
-            const mod = await import(join(commandsDir, entry));
-            if (!mod.description)
-                continue;
-            commands.push({
-                name,
-                funcName: name.replace(/-/g, "_"),
-                description: mod.description,
-                hasArgs: !!mod.args,
-                argCompletion: ARG_COMPLETIONS[name] || null,
-                argCompletionValues: "",
-                options: extractOptions(mod),
-            });
-        }
-        catch {
-            // Skip files that can't be imported
-        }
-    }
-    return commands.sort((a, b) => a.name.localeCompare(b.name));
-}
-// Configure nunjucks
-const templatesDir = join(__dirname, "..", "..", "..", "shell");
-nunjucks.configure(templatesDir, { autoescape: false });
-export default function ShellInit({ args }) {
-    const [shell] = args;
-    const [done, setDone] = useState(false);
-    const hasOutputRef = useRef(false);
-    useEffect(() => {
-        async function run() {
-            if (hasOutputRef.current)
-                return;
-            hasOutputRef.current = true;
-            const commands = await getCommands();
-            const templateFile = `init.${shell}.njk`;
-            const output = nunjucks.render(templateFile, { commands });
-            process.stdout.write(output);
-            setDone(true);
-        }
-        run();
-    }, [shell]);
-    useEffect(() => {
-        if (done) {
-            process.exit(0);
-        }
-    }, [done]);
-    return null;
-}