huddle-cli 0.1.0 → 0.1.1

package/dist/sandbox/worktree.js

@@ -4,6 +4,7 @@
 import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
+import { shellCommand } from "../platform.js";
 /** true if the command exits 0, false if non-zero. */
 function spawnSyncOk(cmd, args, cwd) {
     try {
@@ -57,22 +58,50 @@ export function createWorktree(repoRoot, agentId, taskId) {
 export function listWorktrees(repoRoot) {
     try {
         return git(repoRoot, ["worktree", "list", "--porcelain"])
-            .split("\n")
+            .split(/\r?\n/)
             .filter((l) => l.startsWith("worktree "))
-            .map((l) => l.slice("worktree ".length));
+            // git prints C:/x/y on Windows; resolve() makes it C:\x\y, like path.join does.
+            .map((l) => path.resolve(l.slice("worktree ".length)));
     }
     catch {
         return [];
     }
 }
-export function removeWorktree(repoRoot, wtPath) {
+/**
+ * Best-effort cleanup. Windows can't delete a file another process still has
+ * open (an agent that is just exiting, an editor, a virus scanner), so git
+ * fails with "Permission denied" / EBUSY: retry a few times, then delete the
+ * folder ourselves and let `git worktree prune` forget it.
+ */
+export function removeWorktree(repoRoot, wtPath, tries = process.platform === "win32" ? 4 : 1) {
+    for (let i = 0; i < tries; i++) {
+        try {
+            git(repoRoot, ["worktree", "remove", "--force", wtPath]);
+            return;
+        }
+        catch {
+            if (i < tries - 1)
+                sleepMs(250 * (i + 1));
+        }
+    }
+    if (tries <= 1)
+        return;
+    try {
+        fs.rmSync(wtPath, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 });
+    }
+    catch {
+        /* still locked: prune below won't drop it, a later run's sweep will */
+    }
     try {
-        git(repoRoot, ["worktree", "remove", "--force", wtPath]);
+        git(repoRoot, ["worktree", "prune"]);
     }
     catch {
-        /* best-effort cleanup */
+        /* best effort */
     }
 }
+function sleepMs(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
 /**
  * The merge engine, step 1: commit what the agent produced, run the test gate,
  * and rebase onto the latest main. Nothing lands yet — so a human can look
@@ -95,7 +124,10 @@ export function prepareMerge(repoRoot, wt, testCmd, excludes = [], message = `hu
     }
     if (testCmd) {
         try {
-            execFileSync("sh", ["-c", testCmd], { cwd: wt.path, stdio: "pipe" });
+            // sh on macOS/Linux; cmd.exe on Windows, where `npm test` and friends run as-is.
+            const sh = shellCommand(testCmd, "cmd");
+            // (execFileSync passes windowsVerbatimArguments through to spawn; its types just don't list it)
+            execFileSync(sh.file, sh.args, { cwd: wt.path, stdio: "pipe", ...{ windowsVerbatimArguments: sh.verbatim } });
         }
         catch (e) {
             // The tail of what the tests printed: what the author needs to fix it.
@@ -122,6 +154,45 @@ export function prepareMerge(repoRoot, wt, testCmd, excludes = [], message = `hu
     const diffstat = git(repoRoot, ["diff", "--stat", `${mainBranch}...${wt.branch}`]);
     return { ok: true, reason: testCmd ? "tests green" : "no test command found", diffstat };
 }
+/**
+ * Write one file at the repo root and commit just that path on the current
+ * branch (what every task worktree branches off). Anything else the user has
+ * staged stays staged and out of this commit. false = it couldn't (the run goes on).
+ */
+export function commitFile(repoRoot, rel, content, message) {
+    const file = path.join(repoRoot, rel);
+    const before = fs.existsSync(file) ? fs.readFileSync(file) : null;
+    // A Huddle doc commit, not the user's: their hooks (lint, commitlint, a test
+    // run) don't apply, and a signing prompt or slow hook can't hang the run.
+    const run = (args) => execFileSync("git", args, { cwd: repoRoot, stdio: "ignore", timeout: 30_000 });
+    try {
+        fs.writeFileSync(file, content);
+        run(["add", "--", rel]);
+        if (spawnSyncOk("git", ["diff", "--cached", "--quiet", "--", rel], repoRoot))
+            return true; // unchanged: already committed
+        run(["-c", "commit.gpgsign=false", "commit", "-q", "--no-verify", "--only", "-m", message, "--", rel]);
+        return true;
+    }
+    catch {
+        // Leave the checkout as we found it: no half-staged file, no stray file.
+        try {
+            run(["reset", "-q", "--", rel]);
+        }
+        catch {
+            /* no HEAD yet, or not a repo */
+        }
+        try {
+            if (before)
+                fs.writeFileSync(file, before);
+            else
+                fs.rmSync(file, { force: true });
+        }
+        catch {
+            /* best effort */
+        }
+        return false;
+    }
+}
 /** The merge engine, step 2: fast-forward main to the prepared branch. */
 export function landMerge(repoRoot, wt) {
     const mainBranch = git(repoRoot, ["symbolic-ref", "--short", "HEAD"]);
@@ -131,7 +202,7 @@ export function landMerge(repoRoot, wt) {
     }
     catch (e) {
         // Usually: the user has uncommitted edits in the main checkout on the same files.
-        return { merged: false, reason: `couldn't fast-forward ${mainBranch}: ${String(e?.message ?? e).split("\n")[0]}` };
+        return { merged: false, reason: `couldn't fast-forward ${mainBranch}: ${String(e?.message ?? e).split(/\r?\n/)[0]}` };
     }
 }
 /** The prepared branch's changes vs main, for a reviewer to read. Capped. */
@@ -145,12 +216,70 @@ export function branchDiff(repoRoot, wt, maxChars = 24_000) {
         return "";
     }
 }
+/** Lockfiles: listed as changed, but their diff would bury the real code in a capped prompt. */
+const LOCKFILES = ["package-lock.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "Cargo.lock", "poetry.lock", "Gemfile.lock", "go.sum"];
+/**
+ * Work in progress in a task's worktree, against where it branched off main:
+ * commits, staged and unstaged edits, and new untracked files (minus the Plug
+ * wiring in `excludes`). What a mid-task buddy check and a pairing helper read.
+ * Never throws: a broken worktree is just "no work yet".
+ */
+export function wipDiff(repoRoot, worktree, excludes = [], maxChars = 24_000) {
+    // Raw bytes for names (unicode/spaces stay readable), and room for a big WIP: execFileSync's 1MB default would throw.
+    const run = (cwd, args) => execFileSync("git", ["-c", "core.quotePath=false", ...args], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], maxBuffer: 64 * 1024 * 1024 });
+    const names = (out) => out.split("\0").filter(Boolean);
+    // Untracked symlinks (a linked node_modules, say) aren't work.
+    const isFile = (p) => {
+        try {
+            return fs.lstatSync(p).isFile();
+        }
+        catch {
+            return false;
+        }
+    };
+    try {
+        if (!fs.existsSync(worktree))
+            return { diff: "", files: [] };
+        const mainBranch = git(repoRoot, ["symbolic-ref", "--short", "HEAD"]);
+        const base = git(worktree, ["merge-base", "HEAD", mainBranch]);
+        const ex = excludes.map((x) => `:(exclude)${x}`);
+        const skip = (f) => excludes.some((x) => f === x || f.startsWith(x.replace(/\/+$/, "") + "/"));
+        const tracked = names(run(worktree, ["diff", "--name-only", "-z", base, "--", ".", ...ex]));
+        const untracked = names(run(worktree, ["ls-files", "-z", "--others", "--exclude-standard"])).filter((f) => !skip(f) && isFile(path.join(worktree, f)));
+        let diff = run(worktree, ["diff", base, "--", ".", ...ex, ...LOCKFILES.map((l) => `:(exclude,glob)**/${l}`)]).trim();
+        for (const f of untracked) {
+            if (diff.length > maxChars)
+                break;
+            if (LOCKFILES.includes(path.basename(f)))
+                continue;
+            let body;
+            try {
+                const st = fs.statSync(path.join(worktree, f));
+                if (st.size > 256 * 1024)
+                    body = `(${Math.round(st.size / 1024)} KB, not shown)`;
+                else {
+                    const buf = fs.readFileSync(path.join(worktree, f));
+                    body = buf.includes(0) ? "(binary)" : buf.toString("utf8").slice(0, 6000);
+                }
+            }
+            catch {
+                continue;
+            }
+            diff += `\n--- /dev/null\n+++ b/${f} (new, uncommitted)\n` + body.split("\n").map((l) => "+" + l).join("\n");
+        }
+        diff = diff.trim();
+        return { diff: diff.length > maxChars ? diff.slice(0, maxChars) + "\n… (diff truncated)" : diff, files: [...new Set([...tracked, ...untracked])] };
+    }
+    catch {
+        return { diff: "", files: [] };
+    }
+}
 const MARKER = /^(<{7}|>{7}|\|{7})( |$)/m;
 function mergeInProgress(wtPath) {
     return spawnSyncOk("git", ["rev-parse", "-q", "--verify", "MERGE_HEAD"], wtPath);
 }
 function unmergedFiles(wtPath) {
-    return git(wtPath, ["diff", "--name-only", "--diff-filter=U"]).split("\n").filter(Boolean);
+    return git(wtPath, ["diff", "--name-only", "--diff-filter=U"]).split(/\r?\n/).filter(Boolean);
 }
 /** A file's content at a commit, or null if it doesn't exist there. */
 function showAt(cwd, rev, file) {
@@ -182,7 +311,7 @@ export function beginConflictMerge(repoRoot, wt, message) {
         if (!files.length) {
             // Not a content conflict (e.g. an untracked file in the way): undo and say so.
             spawnSyncOk("git", ["merge", "--abort"], wt.path);
-            return { error: `couldn't merge ${mainBranch} into ${wt.branch}: ${String(e?.stderr ?? e?.message ?? e).trim().split("\n")[0]}` };
+            return { error: `couldn't merge ${mainBranch} into ${wt.branch}: ${String(e?.stderr ?? e?.message ?? e).trim().split(/\r?\n/)[0]}` };
         }
         return { files, ours, theirs, base };
     }
@@ -204,7 +333,7 @@ export function conflictBrief(wt, c, maxPerFile = 6_000) {
             return "";
         }
     };
-    const theirCommits = git(wt.path, ["log", "--format=%s", `${c.base}..${c.theirs}`, "--", ...c.files]).split("\n").filter(Boolean);
+    const theirCommits = git(wt.path, ["log", "--format=%s", `${c.base}..${c.theirs}`, "--", ...c.files]).split(/\r?\n/).filter(Boolean);
     return { marked, oursDiff: diff(c.ours), theirsDiff: diff(c.theirs), theirCommits };
 }
 /**
@@ -225,12 +354,14 @@ export function finishConflictMerge(wt, c, excludes = []) {
             return { ok: false, reason: `still unmerged: ${left.join(", ")}` };
     }
     // The resolver may have committed on its own; judge what the worktree holds either way.
+    // Line endings don't count: with Windows' core.autocrlf the worktree has CRLF, `git show` LF.
+    const eol = (s) => (s === null ? null : s.replace(/\r\n/g, "\n"));
     for (const f of c.files) {
         const p = path.join(wt.path, f);
-        const now = fs.existsSync(p) ? fs.readFileSync(p, "utf8") : null;
-        if (now === showAt(wt.path, c.theirs, f))
+        const now = eol(fs.existsSync(p) ? fs.readFileSync(p, "utf8") : null);
+        if (now === eol(showAt(wt.path, c.theirs, f)))
             return { ok: false, reason: `${f} is just main's version — this task's change was dropped` };
-        if (now === showAt(wt.path, c.ours, f))
+        if (now === eol(showAt(wt.path, c.ours, f)))
             return { ok: false, reason: `${f} is just this task's version — main's change was dropped` };
     }
     try {
@@ -244,7 +375,7 @@ export function finishConflictMerge(wt, c, excludes = []) {
         }
     }
     catch (e) {
-        return { ok: false, reason: `couldn't commit the resolution: ${String(e?.message ?? e).split("\n")[0]}` };
+        return { ok: false, reason: `couldn't commit the resolution: ${String(e?.message ?? e).split(/\r?\n/)[0]}` };
     }
     if (!isAncestor(wt.path, c.theirs, "HEAD") || !isAncestor(wt.path, c.ours, "HEAD"))
         return { ok: false, reason: "the merge was abandoned (main's or this task's commits are missing from the branch)" };