mintree 0.1.8 → 0.1.10

package/dist/commands/dashboard.js

@@ -272,6 +272,83 @@ function buildListRows(issues) {
     });
     return rows;
 }
+/**
+ * Splits the grouped list into a pinned-header region and a scrollable body
+ * windowed around the selected issue. The selected issue's own project and
+ * Status headers are lifted out of the scroll flow so they stay visible
+ * ("sticky") while paging through a long group — without them the user loses
+ * track of which project/status the rows below belong to.
+ *
+ * Navigation is unaffected: it still moves `selectedIndex` over the flat
+ * issues array; this only decides what's drawn where.
+ */
+function windowListRows(listRows, selectedIndex, viewportRows) {
+    const selRow = listRows.findIndex((r) => r.kind === "issue" && r.index === selectedIndex);
+    const anchor = selRow >= 0 ? selRow : 0;
+    // Walk back from the selected row to find its enclosing project and Status
+    // headers. A "Sin proyecto" issue has a project header but no status one.
+    let projIdx = -1;
+    let statusIdx = -1;
+    for (let i = anchor; i >= 0; i--) {
+        const r = listRows[i];
+        if (!r)
+            continue;
+        if (statusIdx === -1 && r.kind === "status")
+            statusIdx = i;
+        if (r.kind === "project") {
+            projIdx = i;
+            break;
+        }
+    }
+    // Pinned rows are pulled out of the body so they never render twice. The
+    // blank spacer that precedes a project header is dropped too, so the pane
+    // doesn't open with an empty line.
+    const pinned = new Set();
+    const sticky = [];
+    if (projIdx >= 0) {
+        pinned.add(projIdx);
+        sticky.push(listRows[projIdx]);
+        const before = listRows[projIdx - 1];
+        if (before && before.kind === "spacer")
+            pinned.add(projIdx - 1);
+    }
+    if (statusIdx >= 0) {
+        pinned.add(statusIdx);
+        sticky.push(listRows[statusIdx]);
+    }
+    const body = [];
+    let anchorInBody = 0;
+    listRows.forEach((r, i) => {
+        if (pinned.has(i))
+            return;
+        if (i === anchor)
+            anchorInBody = body.length;
+        body.push(r);
+    });
+    const bodyViewport = Math.max(1, viewportRows - sticky.length);
+    const maxStart = Math.max(0, body.length - bodyViewport);
+    const start = Math.max(0, Math.min(maxStart, anchorInBody - Math.floor(bodyViewport / 2)));
+    const end = Math.min(body.length, start + bodyViewport);
+    return {
+        sticky,
+        body: body.slice(start, end),
+        issuesAbove: body.slice(0, start).filter((r) => r.kind === "issue").length,
+        issuesBelow: body.slice(end).filter((r) => r.kind === "issue").length,
+    };
+}
+// Renders a single grouped-list row — used for both the sticky header region
+// and the scrollable body so the two stay visually identical.
+function ListRowView({ row, selectedIndex, identifierWidth, maxTitleWidth, width, }) {
+    if (row.kind === "spacer")
+        return _jsx(Text, { children: " " });
+    if (row.kind === "project") {
+        return _jsx(ProjectHeaderRow, { title: row.title, count: row.count, width: width });
+    }
+    if (row.kind === "status") {
+        return _jsx(StatusHeaderRow, { name: row.name, color: row.color, count: row.count, width: width });
+    }
+    return (_jsx(IssueListRow, { d: row.d, selected: row.index === selectedIndex, identifierWidth: identifierWidth, maxTitleWidth: maxTitleWidth }));
+}
 // Word-wraps a single line at `width` columns, breaking on the last space
 // before the limit when that yields a reasonable cut. Falls back to a hard
 // cut for unbroken runs (long URLs, code-fence content) so the detail pane
@@ -980,29 +1057,10 @@ export default function Dashboard() {
     // value without re-binding on every resize.
     listWidthRef.current = listWidth;
     // Grouped list: build the project/status header rows interleaved with
-    // issue rows, then window the rows around the selected issue's row.
-    // Navigation still moves `selectedIndex` over the flat issues array —
-    // headers and spacers are non-selectable, purely visual rows.
+    // issue rows, then split into a sticky header region (the selected issue's
+    // project + Status, pinned to the top) and a windowed scrollable body.
     const listRows = buildListRows(issues);
-    const selectedRowIdx = listRows.findIndex((r) => r.kind === "issue" && r.index === selectedIndex);
-    const rowAnchor = selectedRowIdx >= 0 ? selectedRowIdx : 0;
-    const maxRowStart = Math.max(0, listRows.length - listVisibleRows);
-    const rowStart = Math.max(0, Math.min(maxRowStart, rowAnchor - Math.floor(listVisibleRows / 2)));
-    const rowEnd = Math.min(listRows.length, rowStart + listVisibleRows);
-    const visibleRows = listRows.slice(rowStart, rowEnd);
-    const issuesAbove = listRows.slice(0, rowStart).filter((r) => r.kind === "issue").length;
-    const issuesBelow = listRows.slice(rowEnd).filter((r) => r.kind === "issue").length;
+    const listView = windowListRows(listRows, selectedIndex, listVisibleRows);
     const listContentWidth = Math.max(8, listWidth - 4);
-    return (_jsxs(Box, { flexDirection: "column", width: columns, height: rows, children: [_jsx(Box, { paddingX: 1, paddingTop: 0, flexDirection: "column", children: _jsx(HeaderRow, { repoName: repoName, claudeVersion: claudeVersion, issueCount: issues.length, updateAvailable: latestVersion !== null }) }), overlay ? (_jsx(Box, { flexGrow: 1, flexDirection: "column", borderStyle: "round", borderColor: overlay.kind === "remove" ? "yellow" : "cyan", children: overlay.kind === "create" ? (_jsx(CreateOverlayView, { overlay: overlay, onDescChange: onOverlayDescChange, onPromptChange: onOverlayPromptChange })) : (_jsx(RemoveOverlayView, { overlay: overlay })) })) : (_jsxs(Box, { flexGrow: 1, flexDirection: "row", children: [_jsx(Box, { width: listWidth, flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, children: issues.length === 0 ? (_jsx(Text, { dimColor: true, children: "No open issues assigned to you in this repo." })) : (_jsxs(_Fragment, { children: [visibleRows.map((row, i) => {
-                                    const key = rowStart + i;
-                                    if (row.kind === "spacer")
-                                        return _jsx(Text, { children: " " }, key);
-                                    if (row.kind === "project") {
-                                        return (_jsx(ProjectHeaderRow, { title: row.title, count: row.count, width: listContentWidth }, key));
-                                    }
-                                    if (row.kind === "status") {
-                                        return (_jsx(StatusHeaderRow, { name: row.name, color: row.color, count: row.count, width: listContentWidth }, key));
-                                    }
-                                    return (_jsx(IssueListRow, { d: row.d, selected: row.index === selectedIndex, identifierWidth: identifierWidth, maxTitleWidth: maxTitleWidth }, key));
-                                }), issuesAbove > 0 && _jsxs(Text, { dimColor: true, children: ["\u2191 ", issuesAbove, " more above"] }), issuesBelow > 0 && _jsxs(Text, { dimColor: true, children: ["\u2193 ", issuesBelow, " more below"] })] })) }), _jsx(Box, { width: detailWidth, flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, children: _jsx(DetailPane, { d: selected, contentWidth: detailWidth - 4, contentHeight: detailContentHeight, scrollOffset: state.detailScrollOffset }) })] })), _jsxs(Box, { paddingX: 1, flexDirection: "column", children: [toast && (_jsx(Box, { children: _jsxs(Text, { color: toast.kind === "success" ? "green" : toast.kind === "error" ? "red" : "cyan", children: [toast.kind === "success" ? "✓ " : toast.kind === "error" ? "✗ " : "· ", toast.text] }) })), refreshing && (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { dimColor: true, children: " refreshing" })] })), _jsx(FooterRow, { phase: "ready", overlayKind: overlay?.kind, latestVersion: latestVersion })] })] }));
+    return (_jsxs(Box, { flexDirection: "column", width: columns, height: rows, children: [_jsx(Box, { paddingX: 1, paddingTop: 0, flexDirection: "column", children: _jsx(HeaderRow, { repoName: repoName, claudeVersion: claudeVersion, issueCount: issues.length, updateAvailable: latestVersion !== null }) }), overlay ? (_jsx(Box, { flexGrow: 1, flexDirection: "column", borderStyle: "round", borderColor: overlay.kind === "remove" ? "yellow" : "cyan", children: overlay.kind === "create" ? (_jsx(CreateOverlayView, { overlay: overlay, onDescChange: onOverlayDescChange, onPromptChange: onOverlayPromptChange })) : (_jsx(RemoveOverlayView, { overlay: overlay })) })) : (_jsxs(Box, { flexGrow: 1, flexDirection: "row", children: [_jsx(Box, { width: listWidth, flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, children: issues.length === 0 ? (_jsx(Text, { dimColor: true, children: "No open issues assigned to you in this repo." })) : (_jsxs(_Fragment, { children: [listView.sticky.map((row, i) => (_jsx(ListRowView, { row: row, selectedIndex: selectedIndex, identifierWidth: identifierWidth, maxTitleWidth: maxTitleWidth, width: listContentWidth }, `sticky-${i}`))), listView.issuesAbove > 0 && (_jsxs(Text, { dimColor: true, children: ["\u2191 ", listView.issuesAbove, " more above"] })), listView.body.map((row, i) => (_jsx(ListRowView, { row: row, selectedIndex: selectedIndex, identifierWidth: identifierWidth, maxTitleWidth: maxTitleWidth, width: listContentWidth }, `body-${i}`))), listView.issuesBelow > 0 && (_jsxs(Text, { dimColor: true, children: ["\u2193 ", listView.issuesBelow, " more below"] }))] })) }), _jsx(Box, { width: detailWidth, flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, children: _jsx(DetailPane, { d: selected, contentWidth: detailWidth - 4, contentHeight: detailContentHeight, scrollOffset: state.detailScrollOffset }) })] })), _jsxs(Box, { paddingX: 1, flexDirection: "column", children: [toast && (_jsx(Box, { children: _jsxs(Text, { color: toast.kind === "success" ? "green" : toast.kind === "error" ? "red" : "cyan", children: [toast.kind === "success" ? "✓ " : toast.kind === "error" ? "✗ " : "· ", toast.text] }) })), refreshing && (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: _jsx(Spinner, { type: "dots" }) }), _jsx(Text, { dimColor: true, children: " refreshing" })] })), _jsx(FooterRow, { phase: "ready", overlayKind: overlay?.kind, latestVersion: latestVersion })] })] }));
 }

package/dist/lib/git.d.ts

@@ -43,6 +43,24 @@ export declare function ensureGitignoreEntries(repoRoot: string, entries: string
 export declare function getDefaultBranch(repoRoot: string): string | null;
 export type BranchExistence = "local" | "remote" | null;
 export declare function branchExists(repoRoot: string, branch: string): BranchExistence;
+/**
+ * True when `origin/<branch>` resolves locally. Unlike `branchExists`, this
+ * reports the remote-tracking ref even when a local branch of the same name
+ * also exists — callers that want to fork from the freshest remote tip need
+ * to know the remote ref is there, not just "some ref named X".
+ */
+export declare function remoteBranchExists(repoRoot: string, branch: string): boolean;
+export type FetchResult = {
+    ok: boolean;
+    reason?: string;
+};
+/**
+ * Best-effort `git fetch origin` so worktrees get created off fresh refs
+ * instead of a stale local checkout. Never throws: when there's no `origin`
+ * remote or the network is down, returns `{ ok: false, reason }` and callers
+ * fall back to whatever refs are already local.
+ */
+export declare function fetchRemote(repoRoot: string): FetchResult;
 /**
  * Returns the absolute path where `branch` is checked out as a worktree, or
  * null when the branch is not checked out anywhere. Parses the porcelain

package/dist/lib/git.js

@@ -158,6 +158,38 @@ export function branchExists(repoRoot, branch) {
         return "remote";
     return null;
 }
+/**
+ * True when `origin/<branch>` resolves locally. Unlike `branchExists`, this
+ * reports the remote-tracking ref even when a local branch of the same name
+ * also exists — callers that want to fork from the freshest remote tip need
+ * to know the remote ref is there, not just "some ref named X".
+ */
+export function remoteBranchExists(repoRoot, branch) {
+    return trySh(`git rev-parse --verify --quiet "refs/remotes/origin/${branch}"`, repoRoot) !== null;
+}
+/**
+ * Best-effort `git fetch origin` so worktrees get created off fresh refs
+ * instead of a stale local checkout. Never throws: when there's no `origin`
+ * remote or the network is down, returns `{ ok: false, reason }` and callers
+ * fall back to whatever refs are already local.
+ */
+export function fetchRemote(repoRoot) {
+    if (!trySh("git remote get-url origin", repoRoot)) {
+        return { ok: false, reason: "no origin remote" };
+    }
+    try {
+        execSync("git fetch origin", { cwd: repoRoot, stdio: ["ignore", "pipe", "pipe"] });
+        return { ok: true };
+    }
+    catch (err) {
+        const stderr = err && typeof err === "object" && "stderr" in err
+            ? String(err.stderr).trim()
+            : err instanceof Error
+                ? err.message
+                : String(err);
+        return { ok: false, reason: stderr || "git fetch failed" };
+    }
+}
 /**
  * Returns the absolute path where `branch` is checked out as a worktree, or
  * null when the branch is not checked out anywhere. Parses the porcelain

package/dist/lib/worktreeCreate.js

@@ -3,7 +3,7 @@ import * as os from "os";
 import * as path from "path";
 import { execSync } from "child_process";
 import { parseBranch, isParseError } from "./branch.js";
-import { findMainRepoRoot, getMintreeDir, getWorktreesDir, getInitScriptPath, getDefaultBranch, getCurrentBranch, branchExists, worktreeForBranch, addWorktree, pathExists, isExecutable, } from "./git.js";
+import { findMainRepoRoot, getMintreeDir, getWorktreesDir, getInitScriptPath, getDefaultBranch, getCurrentBranch, branchExists, remoteBranchExists, fetchRemote, worktreeForBranch, addWorktree, pathExists, isExecutable, } from "./git.js";
 import { upsertIssue } from "./metadata.js";
 function tryRunInitScript(scriptPath, worktreePath, repoRoot) {
     if (!pathExists(scriptPath))
@@ -80,6 +80,19 @@ export function runCreate(branchArg, opts) {
             hint: "Remove it first or pick a different branch description.",
         };
     }
+    const steps = [];
+    steps.push({
+        kind: "ok",
+        label: "parsed branch",
+        detail: `type=${parsed.type}, issue=${parsed.issueId}, desc=${parsed.desc}`,
+    });
+    // Fetch before resolving refs so the worktree forks from fresh code, not a
+    // stale local checkout. Best-effort: offline / no-remote just warns and we
+    // fall back to whatever is already local.
+    const fetch = fetchRemote(root);
+    steps.push(fetch.ok
+        ? { kind: "ok", label: "fetched origin", detail: "refs up to date" }
+        : { kind: "warn", label: "skipped git fetch", detail: fetch.reason });
     const existence = branchExists(root, parsed.branch);
     let base;
     if (existence === null) {
@@ -99,14 +112,15 @@ export function runCreate(branchArg, opts) {
             };
         }
     }
-    const steps = [];
-    steps.push({
-        kind: "ok",
-        label: "parsed branch",
-        detail: `type=${parsed.type}, issue=${parsed.issueId}, desc=${parsed.desc}`,
-    });
+    // For a brand-new branch, fork from the freshly fetched `origin/<base>`
+    // tip when origin has it — that's the whole point of the fetch above.
+    // Without a successful fetch (or origin ref) we fork from the local base.
+    let baseRef = base;
+    if (existence === null && base && fetch.ok && remoteBranchExists(root, base)) {
+        baseRef = `origin/${base}`;
+    }
     try {
-        addWorktree({ repoRoot: root, branch: parsed.branch, worktreePath, base });
+        addWorktree({ repoRoot: root, branch: parsed.branch, worktreePath, base: baseRef });
     }
     catch (err) {
         const stderr = err && typeof err === "object" && "stderr" in err
@@ -134,7 +148,7 @@ export function runCreate(branchArg, opts) {
         steps.push({
             kind: "ok",
             label: "created new branch",
-            detail: `${parsed.branch} (from ${base})`,
+            detail: `${parsed.branch} (from ${baseRef})`,
         });
     }
     steps.push({ kind: "ok", label: "worktree created", detail: worktreePath });
@@ -243,8 +257,15 @@ export function runCreateDetached(opts) {
         label: "detached worktree",
         detail: `issue=${opts.issueId}, base=${currentBranch}`,
     });
+    // Fetch so the detached worktree forks from the fresh remote tip of the
+    // current branch instead of a stale local checkout. Best-effort.
+    const fetch = fetchRemote(root);
+    steps.push(fetch.ok
+        ? { kind: "ok", label: "fetched origin", detail: "refs up to date" }
+        : { kind: "warn", label: "skipped git fetch", detail: fetch.reason });
+    const baseRef = fetch.ok && remoteBranchExists(root, currentBranch) ? `origin/${currentBranch}` : currentBranch;
     try {
-        execSync(`git worktree add --detach '${worktreePath.replace(/'/g, `'\\''`)}' '${currentBranch.replace(/'/g, `'\\''`)}'`, { cwd: root, stdio: ["ignore", "pipe", "pipe"] });
+        execSync(`git worktree add --detach '${worktreePath.replace(/'/g, `'\\''`)}' '${baseRef.replace(/'/g, `'\\''`)}'`, { cwd: root, stdio: ["ignore", "pipe", "pipe"] });
     }
     catch (err) {
         const stderr = err && typeof err === "object" && "stderr" in err
@@ -257,7 +278,7 @@ export function runCreateDetached(opts) {
     steps.push({
         kind: "ok",
         label: "checked out detached HEAD",
-        detail: `at tip of ${currentBranch}`,
+        detail: `at tip of ${baseRef}`,
     });
     steps.push({ kind: "ok", label: "worktree created", detail: worktreePath });
     upsertIssue(root, opts.issueId, { base_branch: currentBranch });

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mintree",
-	"version": "0.1.8",
+	"version": "0.1.10",
 	"description": "Issue-driven git worktrees + Claude Code sessions for repos with an opinionated SDD+TDD flow.",
 	"license": "MIT",
 	"author": "Martin Mineo <mmineo@canarytechnologies.com>",