santree 0.5.6 → 0.6.0

package/dist/lib/open-url.js

@@ -0,0 +1,20 @@
+import { execSync } from "child_process";
+/**
+ * Open a URL in the platform's default browser.
+ *   macOS → `open <url>`
+ *   else  → `xdg-open <url>`
+ *
+ * Returns true on apparent success, false on failure. Callers decide how to
+ * surface failures (e.g. a dashboard action message). Uses execSync with
+ * `stdio: "ignore"` — fast, no output leak into the dashboard's alt screen.
+ */
+export function openUrl(url) {
+    try {
+        const cmd = process.platform === "darwin" ? "open" : "xdg-open";
+        execSync(`${cmd} "${url}"`, { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,9 @@
+interface Props {
+    text?: 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 {};

package/dist/lib/squirrel-loader.js

@@ -0,0 +1,322 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useState } from "react";
+import { Box, Text } from "ink";
+// ─────────────────────────────────────────────────────────────────────────
+// 3D rendered squirrel via SDF + sphere tracing.
+//
+// Anatomy is composed of ellipsoid/sphere/capsule primitives blended with
+// smooth-min so the silhouette looks organic. Per-pixel ray-marching
+// finds the surface; surface normals are finite-differenced. Lighting
+// combines Lambertian diffuse, soft shadows (Inigo Quilez technique),
+// and ambient occlusion. Brightness picks a glyph from a luminance ramp;
+// world-Y position picks a rainbow color band (red top → blue bottom)
+// with shadow/lit two-tone variants.
+//
+// Animation runs on three independent phases per loop (so nothing reads
+// as a single synchronised pendulum):
+//   - body angle: 1 full Y-rotation (every face visible)
+//   - tail phase: 3 wag cycles
+//   - anim phase: 1 cycle, with BodyAnim curves using internal multiples
+//     (×5 for ear flicks, ×2 for acorn jiggle) for per-part timing
+// ─────────────────────────────────────────────────────────────────────────
+const W = 100;
+const H = 40;
+const FRAME_COUNT = 36;
+const FRAME_MS = 80;
+const RAMP = ".,-~:;=!*#$@";
+const sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+const addV = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+const vlen = (a) => Math.hypot(a[0], a[1], a[2]);
+const vscale = (a, s) => [a[0] * s, a[1] * s, a[2] * s];
+function vnorm(a) {
+    const l = vlen(a) || 1;
+    return [a[0] / l, a[1] / l, a[2] / l];
+}
+// Rotate around Y axis. `c`/`s` are precomputed cos/sin so callers can
+// share them across many evals at the same angle.
+const rotY = (p, c, s) => [c * p[0] + s * p[2], p[1], -s * p[0] + c * p[2]];
+// ── SDF primitives ──────────────────────────────────────────────────
+function sdEllipsoid(p, r) {
+    const k0 = Math.hypot(p[0] / r[0], p[1] / r[1], p[2] / r[2]);
+    const k1 = Math.hypot(p[0] / (r[0] * r[0]), p[1] / (r[1] * r[1]), p[2] / (r[2] * r[2]));
+    return (k0 * (k0 - 1)) / Math.max(0.0001, k1);
+}
+const sdSphere = (p, r) => vlen(p) - r;
+function sdCapsule(p, a, b, r) {
+    const pa = sub(p, a);
+    const ba = sub(b, a);
+    const h = Math.max(0, Math.min(1, dot(pa, ba) / dot(ba, ba)));
+    return vlen(sub(pa, vscale(ba, h))) - r;
+}
+function smin(a, b, k) {
+    const h = Math.max(0, k - Math.abs(a - b)) / k;
+    return Math.min(a, b) - h * h * k * 0.25;
+}
+// ── Animation curves ────────────────────────────────────────────────
+// Tail joint base positions. Peak (j5) is at y=2.7, level with the ear
+// tips — tail no longer towers over the silhouette. Tip is well to the
+// left (x=-1.1) and behind (z=0.0) so it stays clear of the head/ears.
+const TAIL_BASES = [
+    [-1.4, -0.4, -0.4], // anchor at rump
+    [-1.9, 0.3, -0.6],
+    [-2.2, 1.1, -0.6],
+    [-2.3, 1.9, -0.4], // peak of outward arc
+    [-1.9, 2.5, -0.2],
+    [-1.1, 2.7, 0.0], // tip — at ear height, behind & left of head
+];
+// Per-frame tail joints: amplitude scales with joint index (rump stays
+// anchored, tip flicks). Phase shift per joint creates a travelling
+// wave instead of a synchronised wag.
+function computeTailJoints(phase) {
+    return TAIL_BASES.map((b, i) => {
+        const amp = i / 5;
+        const wagX = Math.sin(phase + i * 0.6) * 0.7 * amp;
+        const liftY = Math.cos(phase * 0.9 + i * 0.4) * 0.5 * amp;
+        return [b[0] + wagX, b[1] + liftY, b[2]];
+    });
+}
+function computeBodyAnim(phase) {
+    const bobY = Math.sin(phase) * 0.35;
+    return {
+        bodyBobY: bobY,
+        stretchY: bobY * 0.4,
+        headExtraY: Math.sin(phase * 1.6 + 0.5) * 0.18,
+        headTurnAngle: Math.sin(phase * 0.7) * 0.45,
+        headLeanZ: Math.sin(phase * 1.3 + 1.0) * 0.18,
+        earLExtraY: Math.max(0, Math.sin(phase * 5)) * 0.35,
+        earRExtraY: Math.max(0, Math.sin(phase * 5 + 1.7)) * 0.35,
+        snoutWiggleZ: Math.sin(phase * 4) * 0.1,
+        pawForwardZ: Math.max(0, Math.sin(phase * 3 - 0.5)) * 0.15,
+        acornBobY: Math.sin(phase * 2 + 1) * 0.15,
+    };
+}
+// Tail capsule radii from base (rump) to tip. Defined alongside the
+// joint positions so anyone tweaking shape sees both at once.
+const TAIL_RADII = [0.5, 0.6, 0.65, 0.6, 0.45];
+function tailSDF(p, tj) {
+    const t1 = sdCapsule(p, tj[0], tj[1], TAIL_RADII[0]);
+    const t2 = sdCapsule(p, tj[1], tj[2], TAIL_RADII[1]);
+    const t3 = sdCapsule(p, tj[2], tj[3], TAIL_RADII[2]);
+    const t4 = sdCapsule(p, tj[3], tj[4], TAIL_RADII[3]);
+    const t5 = sdCapsule(p, tj[4], tj[5], TAIL_RADII[4]);
+    // Internal smooth-min keeps the tail one continuous bushy curve.
+    return smin(smin(smin(t1, t2, 0.3), smin(t3, t4, 0.3), 0.3), t5, 0.3);
+}
+// SDF evaluated in body-local space (point already rotated by camera
+// spin). Returns signed distance to the squirrel surface.
+function squirrelLocal(p, state) {
+    const { tj, anim } = state;
+    // Whole-body bob: shift the eval point down by bodyBobY, equivalent
+    // to moving the body up by bodyBobY. The tail uses ps too so it
+    // bobs with the body.
+    const ps = [p[0], p[1] - anim.bodyBobY, p[2]];
+    // Volume-preserving squash & stretch: Y grows when stretchY > 0,
+    // X/Z shrink slightly to compensate.
+    const sy = 1 + anim.stretchY;
+    const sxz = 1 - anim.stretchY * 0.5;
+    // Pear-shape body: wider haunches, narrower chest.
+    const haunches = sdEllipsoid(sub(ps, [0, -0.3, 0]), [1.2 * sxz, 1.0 * sy, 1.0 * sxz]);
+    const chest = sdEllipsoid(sub(ps, [0, 0.7, 0.1]), [0.9 * sxz, 0.9 * sy, 0.85 * sxz]);
+    const body = smin(haunches, chest, 0.3);
+    // Head primitives evaluated in a head-local frame: rotate the eval
+    // point around a neck pivot by -headTurnAngle so the head appears
+    // to look L/R while the body stays straight.
+    const headPivot = [0, 1.4, 0.2];
+    const cosTurn = Math.cos(anim.headTurnAngle);
+    const sinTurn = Math.sin(anim.headTurnAngle);
+    const psHead = addV(rotY(sub(ps, headPivot), cosTurn, sinTurn), headPivot);
+    const lean = anim.headLeanZ;
+    const head = sdEllipsoid(sub(psHead, [0, 1.85 + anim.headExtraY, 0.4 + lean]), [0.7, 0.65, 0.7]);
+    const snout = sdEllipsoid(sub(psHead, [0, 1.65 + anim.headExtraY, 1.0 + lean + anim.snoutWiggleZ]), [0.32, 0.28, 0.4]);
+    const earL = sdEllipsoid(sub(psHead, [-0.45, 2.7 + anim.earLExtraY, 0.25 + lean]), [0.16, 0.45, 0.18]);
+    const earR = sdEllipsoid(sub(psHead, [0.45, 2.7 + anim.earRExtraY, 0.25 + lean]), [0.16, 0.45, 0.18]);
+    // Paws + acorn shift forward together (nibble lunge).
+    const pe = anim.pawForwardZ;
+    const pawL = sdSphere(sub(ps, [-0.45, 0.7, 0.95 + pe]), 0.3);
+    const pawR = sdSphere(sub(ps, [0.45, 0.7, 0.95 + pe]), 0.3);
+    const acorn = sdEllipsoid(sub(ps, [0, 0.55 + anim.acornBobY, 1.15 + pe]), [0.22, 0.28, 0.22]);
+    const tail = tailSDF(ps, tj);
+    let d = body;
+    d = smin(d, head, 0.25);
+    d = smin(d, snout, 0.2);
+    d = Math.min(d, earL); // hard union for ears (keeps them pointy)
+    d = Math.min(d, earR);
+    d = smin(d, pawL, 0.2);
+    d = smin(d, pawR, 0.2);
+    d = Math.min(d, acorn);
+    d = Math.min(d, tail); // hard union: tail is its own visible silhouette
+    return d;
+}
+// SDF at a world-space point: rotates into body-local frame, evaluates.
+function evalAt(p, state) {
+    return squirrelLocal(rotY(p, state.cosA, state.sinA), state);
+}
+function calcNormal(p, state) {
+    const e = 0.01;
+    return vnorm([
+        evalAt(addV(p, [e, 0, 0]), state) - evalAt(addV(p, [-e, 0, 0]), state),
+        evalAt(addV(p, [0, e, 0]), state) - evalAt(addV(p, [0, -e, 0]), state),
+        evalAt(addV(p, [0, 0, e]), state) - evalAt(addV(p, [0, 0, -e]), state),
+    ]);
+}
+// Soft shadow via light-direction march (Inigo Quilez technique). The
+// closest miss along the ray gives a partial shadow; the k=10 multiplier
+// controls penumbra softness.
+function softShadow(origin, dir, state) {
+    let res = 1.0;
+    let t = 0.05; // step off the surface to avoid self-occlusion
+    for (let step = 0; step < 20; step++) {
+        const sp = [origin[0] + dir[0] * t, origin[1] + dir[1] * t, origin[2] + dir[2] * t];
+        const d = evalAt(sp, state);
+        if (d < 0.001)
+            return 0;
+        res = Math.min(res, (10 * d) / t);
+        t += d;
+        if (t > 8)
+            break;
+    }
+    return Math.max(0, Math.min(1, res));
+}
+// Cheap ambient occlusion: sample SDF along the surface normal at
+// increasing distances. Concave creases (ear bases, where tail meets
+// body, under the chin) get darker because nearby geometry blocks the
+// ambient light.
+function ao(p, n, state) {
+    let occ = 0;
+    let sca = 1.0;
+    for (let i = 0; i < 5; i++) {
+        const h = 0.04 + 0.12 * i;
+        const sp = [p[0] + n[0] * h, p[1] + n[1] * h, p[2] + n[2] * h];
+        const d = evalAt(sp, state);
+        occ += (h - d) * sca;
+        sca *= 0.85;
+    }
+    return Math.max(0, Math.min(1, 1.0 - 0.8 * occ));
+}
+// ── Frame construction ──────────────────────────────────────────────
+const LIGHT = vnorm([0.5, 0.6, -0.6]);
+// Viewport in world space (orthographic). The squirrel spans roughly
+// y=-1 (paws) to y=4.5 (ear tips), x=-2.5 (tail) to x=1.5 (snout).
+const VIEW_X_MIN = -3.5;
+const VIEW_X_MAX = 3.5;
+const VIEW_Y_MID = 1.75;
+const VIEW_Y_HALF = 2.75;
+const RAY_MAX_T = 12;
+const RAY_MAX_STEPS = 60;
+const HIT_EPS = 0.01;
+// Ambient floor keeps shadow regions clearly visible. A floor of 0.12
+// produced internal "holes" in the silhouette that broke the shape.
+const AMBIENT = 0.35;
+const EMPTY_CELL = { ch: " ", y: 0, lit: 0 };
+function buildFrame(angle, tailPhase, animPhase) {
+    const state = {
+        cosA: Math.cos(angle),
+        sinA: Math.sin(angle),
+        tj: computeTailJoints(tailPhase),
+        anim: computeBodyAnim(animPhase),
+    };
+    const grid = Array.from({ length: H }, () => Array.from({ length: W }, () => ({ ...EMPTY_CELL })));
+    for (let py = 0; py < H; py++) {
+        for (let px = 0; px < W; px++) {
+            const xw = VIEW_X_MIN + (px / (W - 1)) * (VIEW_X_MAX - VIEW_X_MIN);
+            const yw = VIEW_Y_MID + (1 - (py / (H - 1)) * 2) * VIEW_Y_HALF;
+            // Sphere-trace from in front of the model toward +Z (orthographic).
+            let t = 0;
+            let p = [xw, yw, -5];
+            let hit = false;
+            for (let step = 0; step < RAY_MAX_STEPS; step++) {
+                p = [xw, yw, -5 + t];
+                const d = evalAt(p, state);
+                if (d < HIT_EPS) {
+                    hit = true;
+                    break;
+                }
+                if (t > RAY_MAX_T)
+                    break;
+                t += d;
+            }
+            if (!hit)
+                continue;
+            const n = calcNormal(p, state);
+            const diffuse = Math.max(0, dot(n, LIGHT));
+            // Offset shadow ray origin along the normal so we don't
+            // immediately re-hit the surface we just landed on.
+            const shadowOrigin = [p[0] + n[0] * 0.03, p[1] + n[1] * 0.03, p[2] + n[2] * 0.03];
+            const sh = softShadow(shadowOrigin, LIGHT, state);
+            const occ = ao(p, n, state);
+            const lit = Math.min(1, AMBIENT + (1 - AMBIENT) * diffuse * sh * occ);
+            const idx = Math.min(RAMP.length - 1, Math.floor(lit * 1.3 * RAMP.length));
+            // World Y = p[1] (rotY only rotates around Y, so Y is preserved).
+            grid[py][px] = { ch: RAMP[idx], y: p[1], lit };
+        }
+    }
+    return grid;
+}
+// Pre-compute every frame at module load; render path stays at zero
+// math per tick.
+const FRAMES = (() => {
+    const out = [];
+    for (let i = 0; i < FRAME_COUNT; i++) {
+        const t = i / FRAME_COUNT;
+        const angle = t * Math.PI * 2;
+        const tailPhase = t * Math.PI * 6; // 3 wag cycles per loop
+        const animPhase = t * Math.PI * 2;
+        out.push(buildFrame(angle, tailPhase, animPhase));
+    }
+    return out;
+})();
+// ── Color rendering ─────────────────────────────────────────────────
+// Each band has lit/shadow variants of the same hue. Bundling them
+// into one array means adding a band is a single-line change.
+const COLOR_BANDS = [
+    { lit: "redBright", shadow: "red" }, // top of head/ears
+    { lit: "yellowBright", shadow: "yellow" },
+    { lit: "yellowBright", shadow: "yellow" },
+    { lit: "greenBright", shadow: "green" },
+    { lit: "cyanBright", shadow: "cyan" },
+    { lit: "cyanBright", shadow: "cyan" },
+    { lit: "blueBright", shadow: "blue" }, // bottom (paws/feet)
+];
+// World Y range mapped onto bands. Squirrel spans roughly y=-1..3.5.
+const COLOR_Y_MIN = -1;
+const COLOR_Y_RANGE = 4.5;
+const SHADOW_THRESHOLD = 0.5;
+function colorForCell(y, lit) {
+    const t = Math.max(0, Math.min(0.999, (y - COLOR_Y_MIN) / COLOR_Y_RANGE));
+    const idx = Math.min(COLOR_BANDS.length - 1, Math.max(0, Math.floor((1 - t) * COLOR_BANDS.length)));
+    const band = COLOR_BANDS[idx];
+    return lit < SHADOW_THRESHOLD ? band.shadow : band.lit;
+}
+/** 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 }) {
+    const [frame, setFrame] = useState(0);
+    useEffect(() => {
+        const id = setInterval(() => setFrame((f) => (f + 1) % FRAMES.length), FRAME_MS);
+        return () => clearInterval(id);
+    }, []);
+    // Coalesce contiguous same-color cells into single Text spans —
+    // without this we'd hand Ink ~4000 nodes per frame and stutter.
+    const rows = useMemo(() => {
+        const grid = FRAMES[frame];
+        return grid.map((row) => {
+            const spans = [];
+            let cur = null;
+            for (const cell of row) {
+                const color = cell.ch === " " ? undefined : colorForCell(cell.y, cell.lit);
+                if (!cur || cur.color !== color) {
+                    cur = { text: cell.ch, color };
+                    spans.push(cur);
+                }
+                else {
+                    cur.text += cell.ch;
+                }
+            }
+            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 }) }))] }));
+}

package/dist/lib/trackers/index.d.ts

@@ -10,3 +10,16 @@ export { setRepoTracker, removeRepoTracker, readTrackerConfig } from "./config.j
  */
 export declare function getIssueTracker(repoRoot: string | null): IssueTracker;
 export declare function getActiveTrackerKind(repoRoot: string | null): IssueTrackerKind;
+/**
+ * Trackers worth trying when resolving a ticket from a foreign PR branch.
+ *
+ * The active tracker is always first. When the active tracker is GitHub but
+ * the user has stored Linear credentials, Linear is appended as a fallback —
+ * the typical reviewer scenario is a santree-managed repo (active tracker:
+ * GitHub) reviewing PRs from a Linear-driven team where branches encode
+ * `TEAM-1234`-style IDs that GitHub's parser ignores.
+ *
+ * Only used by features that look at OTHER people's branches (like the
+ * reviews tab). Per-repo flows still use the active tracker exclusively.
+ */
+export declare function getCandidateTrackers(repoRoot: string | null): IssueTracker[];

package/dist/lib/trackers/index.js

@@ -32,3 +32,22 @@ export function getIssueTracker(repoRoot) {
 export function getActiveTrackerKind(repoRoot) {
     return getIssueTracker(repoRoot).kind;
 }
+/**
+ * Trackers worth trying when resolving a ticket from a foreign PR branch.
+ *
+ * The active tracker is always first. When the active tracker is GitHub but
+ * the user has stored Linear credentials, Linear is appended as a fallback —
+ * the typical reviewer scenario is a santree-managed repo (active tracker:
+ * GitHub) reviewing PRs from a Linear-driven team where branches encode
+ * `TEAM-1234`-style IDs that GitHub's parser ignores.
+ *
+ * Only used by features that look at OTHER people's branches (like the
+ * reviews tab). Per-repo flows still use the active tracker exclusively.
+ */
+export function getCandidateTrackers(repoRoot) {
+    const active = getIssueTracker(repoRoot);
+    if (active.kind === "github" && Object.keys(readLinearAuthStore()).length > 0) {
+        return [active, linearTracker];
+    }
+    return [active];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "santree",
-	"version": "0.5.6",
+	"version": "0.6.0",
 	"description": "Git worktree manager",
 	"license": "MIT",
 	"author": "Santiago Toscanini",

package/prompts/fill-commit.njk

@@ -0,0 +1,79 @@
+You are writing a Git commit message. Output ONLY the message string itself — no preamble, no quotes, no markdown, no explanation.
+
+# Format rules
+
+The message is **a single line** — no newlines, no body paragraphs.
+
+If the diff covers multiple changes, list each one as a brief phrase joined by a `+`. Each phrase is one short imperative clause — never a sentence.
+
+```
+[ABC-1] add login throttling + fix token refresh race + rename UserService
+```
+
+If the diff is one change, write one phrase, no separator.
+
+```
+[ABC-1] add login throttling
+```
+
+# Per-phrase rules (apply to every clause in the message)
+
+- Imperative mood: "add", "fix", "update", "rename", "remove" — NEVER "added", "fixing", "updates".
+- Lowercase first letter (after any [TICKET] prefix).
+- Concise — describe the change in 3–8 words. No "and that does X also" hedging.
+- No trailing period. No wrapping quotes.
+{% if ticket_id %}- The whole message is prefixed once: `[{{ ticket_id }}] ` (square brackets, single space). The prefix is not repeated per clause.{% endif %}
+
+# What to include vs drop
+
+Include user-facing changes — new commands, new keybindings, new UI surfaces, user-visible bugfixes, behaviour changes a user would notice.
+
+Drop or merge into a parent phrase:
+- Pure type/interface refactors that exist only to support an included feature
+- Internal helper extractions (e.g. "extract X into util") unless they ARE the entire commit
+- Prompt tweaks that go with a feature you already mentioned
+- Dependency bumps from `npm install` triggered by an included feature
+
+If the diff is genuinely 100% internal (refactor commit, no user-facing change), write one phrase about the structural change.
+
+# Good examples
+
+{% if ticket_id %}[{{ ticket_id }}] add dashboard help overlay + show main repo row + draft commit messages with claude
+[{{ ticket_id }}] fix tail rendering in squirrel loader + speed up frame generation
+[{{ ticket_id }}] rename UserService to AccountService{% else %}add dashboard help overlay + show main repo row + draft commit messages with claude
+fix tail rendering in squirrel loader + speed up frame generation
+rename UserService to AccountService{% endif %}
+
+# Bad examples (do NOT do this)
+
+- `Added the help overlay.`                                ← past tense + period
+- `add the help overlay and also fix the squirrel tail`    ← prose-y "and" + "also"; use `+`
+- `add help overlay\nfix tail rendering`                   ← multi-line; must be a single line
+- `"add help overlay"`                                     ← wrapped in quotes
+- `add help overlay, fix tail, refactor types, bump deps`  ← drop "refactor types" and "bump deps" if they support a listed feature
+
+# Context
+
+Branch: {{ branch_name }}
+{% if ticket_id %}Ticket: {{ ticket_id }}{% endif %}
+{% if ticket_content %}
+{{ ticket_content }}
+{% endif %}
+
+# Staged diff
+
+```
+{{ diff_content }}
+```
+
+# Final self-check
+
+1. Is the message a single line (no newlines)?
+2. Does each clause start with an imperative verb (add/fix/update/…)?
+3. Are clauses separated by ` + ` (with spaces around the plus)?
+4. Have I dropped clauses that just support another included clause?
+5. Is each clause concise (under ~8 words)?
+
+# Output
+
+Output ONLY the final commit message string. Nothing before, nothing after.