huddle-cli 0.0.0-stage → 0.1.1

package/dist/sandbox/worktree.js

@@ -0,0 +1,392 @@
+// Sandboxes = git worktrees. Each claimed task gets its own working copy that
+// shares the repo's object store, so isolation is cheap and "merging" is just
+// git. The user never sees any of this — it's the hidden plumbing.
+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 {
+        execFileSync(cmd, args, { cwd, stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function git(cwd, args) {
+    return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+}
+/** true if `a` is an ancestor of (or the same commit as) `b`. */
+function isAncestor(cwd, a, b) {
+    return spawnSyncOk("git", ["merge-base", "--is-ancestor", a, b], cwd);
+}
+export function isGitRepo(dir) {
+    try {
+        git(dir, ["rev-parse", "--is-inside-work-tree"]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Create an isolated worktree for a task, branched off the current HEAD.
+ * Worktrees live under .huddle/worktrees/ so they're easy to clean up.
+ */
+/** Where a task's worktree lives — computed without touching disk. */
+export function worktreeFor(repoRoot, agentId, taskId) {
+    const slug = `${agentId}-${taskId}`.replace(/[^\w.-]/g, "_");
+    return { branch: `huddle/${slug}`, path: path.join(repoRoot, ".huddle", "worktrees", slug) };
+}
+export function createWorktree(repoRoot, agentId, taskId) {
+    const { branch, path: wtPath } = worktreeFor(repoRoot, agentId, taskId);
+    fs.mkdirSync(path.dirname(wtPath), { recursive: true });
+    if (fs.existsSync(wtPath))
+        return { branch, path: wtPath };
+    // Reuse the branch if it already exists, else create it.
+    const branches = git(repoRoot, ["branch", "--list", branch]);
+    if (branches) {
+        git(repoRoot, ["worktree", "add", wtPath, branch]);
+    }
+    else {
+        git(repoRoot, ["worktree", "add", "-b", branch, wtPath, "HEAD"]);
+    }
+    return { branch, path: wtPath };
+}
+export function listWorktrees(repoRoot) {
+    try {
+        return git(repoRoot, ["worktree", "list", "--porcelain"])
+            .split(/\r?\n/)
+            .filter((l) => l.startsWith("worktree "))
+            // 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 [];
+    }
+}
+/**
+ * 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", "prune"]);
+    }
+    catch {
+        /* 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
+ * first in manual mode. Tests are the referee: nothing merges on agent vibes.
+ */
+export function prepareMerge(repoRoot, wt, testCmd, excludes = [], message = `huddle: ${wt.branch}`) {
+    // Commit — minus Huddle's own Plug wiring files, which must never reach history.
+    try {
+        // An exclusion for a path that's already ignored (e.g. `huddle connect` put
+        // it in .git/info/exclude) makes `git add` fail outright — skip those.
+        const live = excludes.filter((e) => spawnSyncOk("git", ["check-ignore", "-q", e], wt.path) === false);
+        git(wt.path, ["add", "-A", "--", ".", ...live.map((e) => `:!${e}`)]);
+        // Only commit if something is staged (delegated branches arrive committed).
+        const staged = spawnSyncOk("git", ["diff", "--cached", "--quiet"], wt.path) === false;
+        if (staged)
+            git(wt.path, ["commit", "-m", message]);
+    }
+    catch {
+        /* nothing to commit */
+    }
+    if (testCmd) {
+        try {
+            // 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.
+            const out = `${e?.stdout ?? ""}\n${e?.stderr ?? ""}`.trim();
+            return { ok: false, reason: `tests failed: ${String(e?.message ?? e).slice(0, 200)}`, diffstat: "", testOutput: out.slice(-3000) };
+        }
+    }
+    const mainBranch = git(repoRoot, ["symbolic-ref", "--short", "HEAD"]);
+    if (!isAncestor(wt.path, mainBranch, "HEAD")) {
+        // A branch whose conflict was resolved carries a merge commit: replaying it
+        // with rebase would raise the same conflict again, so bring main in by merge.
+        const resolvedBefore = git(wt.path, ["rev-list", "--merges", `${mainBranch}..HEAD`]) !== "";
+        try {
+            if (resolvedBefore)
+                git(wt.path, ["merge", "--no-edit", mainBranch]);
+            else
+                git(wt.path, ["rebase", mainBranch]);
+        }
+        catch {
+            spawnSyncOk("git", [resolvedBefore ? "merge" : "rebase", "--abort"], wt.path);
+            return { ok: false, conflict: true, reason: "conflict on rebase — needs resolver", diffstat: "" };
+        }
+    }
+    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"]);
+    try {
+        git(repoRoot, ["merge", "--ff-only", wt.branch]);
+        return { merged: true, reason: "merged" };
+    }
+    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(/\r?\n/)[0]}` };
+    }
+}
+/** The prepared branch's changes vs main, for a reviewer to read. Capped. */
+export function branchDiff(repoRoot, wt, maxChars = 24_000) {
+    const mainBranch = git(repoRoot, ["symbolic-ref", "--short", "HEAD"]);
+    try {
+        const d = git(repoRoot, ["diff", `${mainBranch}...${wt.branch}`]);
+        return d.length > maxChars ? d.slice(0, maxChars) + "\n… (diff truncated)" : d;
+    }
+    catch {
+        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(/\r?\n/).filter(Boolean);
+}
+/** A file's content at a commit, or null if it doesn't exist there. */
+function showAt(cwd, rev, file) {
+    try {
+        return execFileSync("git", ["show", `${rev}:${file}`], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Start merging main into the task branch; stops on conflicts with markers in
+ * the files. `files` empty = it merged cleanly (main moved on to something
+ * compatible) and the merge is already committed.
+ */
+export function beginConflictMerge(repoRoot, wt, message) {
+    const mainBranch = git(repoRoot, ["symbolic-ref", "--short", "HEAD"]);
+    if (mergeInProgress(wt.path))
+        spawnSyncOk("git", ["merge", "--abort"], wt.path);
+    const ours = git(wt.path, ["rev-parse", "HEAD"]);
+    const theirs = git(repoRoot, ["rev-parse", mainBranch]);
+    const base = git(wt.path, ["merge-base", ours, theirs]);
+    try {
+        git(wt.path, ["-c", "merge.conflictStyle=diff3", "merge", "--no-ff", "-m", message, theirs]);
+        return { files: [], ours, theirs, base };
+    }
+    catch (e) {
+        const files = unmergedFiles(wt.path);
+        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(/\r?\n/)[0]}` };
+        }
+        return { files, ours, theirs, base };
+    }
+}
+/** Both sides of a conflict, for the resolver's prompt. Capped. */
+export function conflictBrief(wt, c, maxPerFile = 6_000) {
+    const cap = (s, n) => (s.length > n ? s.slice(0, n) + "\n… (truncated)" : s);
+    const marked = c.files
+        .map((f) => {
+        const p = path.join(wt.path, f);
+        return `--- ${f}\n${fs.existsSync(p) ? cap(fs.readFileSync(p, "utf8"), maxPerFile) : "(deleted on one side)"}`;
+    })
+        .join("\n\n");
+    const diff = (to) => {
+        try {
+            return cap(git(wt.path, ["diff", c.base, to, "--", ...c.files]), maxPerFile * 2);
+        }
+        catch {
+            return "";
+        }
+    };
+    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 };
+}
+/**
+ * Check the resolver's work and commit the merge. Refuses if markers remain,
+ * files are still unmerged, or a file is byte-identical to one side — taking
+ * one side wholesale drops the other agent's change.
+ */
+export function finishConflictMerge(wt, c, excludes = []) {
+    for (const f of c.files) {
+        const p = path.join(wt.path, f);
+        if (fs.existsSync(p) && MARKER.test(fs.readFileSync(p, "utf8")))
+            return { ok: false, reason: `conflict markers left in ${f}` };
+    }
+    if (mergeInProgress(wt.path)) {
+        git(wt.path, ["add", "-A", "--", ".", ...excludes.map((e) => `:!${e}`)]);
+        const left = unmergedFiles(wt.path);
+        if (left.length)
+            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 = 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 === eol(showAt(wt.path, c.ours, f)))
+            return { ok: false, reason: `${f} is just this task's version — main's change was dropped` };
+    }
+    try {
+        if (mergeInProgress(wt.path))
+            git(wt.path, ["commit", "--no-edit"]);
+        else {
+            // Committed by the resolver: anything still uncommitted belongs with it.
+            git(wt.path, ["add", "-A", "--", ".", ...excludes.map((e) => `:!${e}`)]);
+            if (!spawnSyncOk("git", ["diff", "--cached", "--quiet"], wt.path))
+                git(wt.path, ["commit", "-m", "huddle: finish conflict resolution"]);
+        }
+    }
+    catch (e) {
+        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)" };
+    return { ok: true, reason: `resolved ${c.files.join(", ")}` };
+}
+/** Give up on a resolution: the branch goes back to exactly the task's own commits. */
+export function abortConflictMerge(wt, c) {
+    if (mergeInProgress(wt.path))
+        spawnSyncOk("git", ["merge", "--abort"], wt.path);
+    // A bad resolution the resolver committed itself: drop it (it stays in the reflog).
+    if (git(wt.path, ["rev-parse", "HEAD"]) !== c.ours)
+        spawnSyncOk("git", ["reset", "--hard", c.ours], wt.path);
+}
+//# sourceMappingURL=worktree.js.map

package/dist/types.js

@@ -0,0 +1,4 @@
+// Shared types for the Huddle daemon. The Room is the single source of truth;
+// these mirror the SQLite schema in room/db.ts.
+export {};
+//# sourceMappingURL=types.js.map