mintree 0.1.9 → 0.1.10

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.9",
+	"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>",