huddle-cli 0.0.0-stage → 0.1.0

package/dist/sandbox/worktree.js

@@ -0,0 +1,261 @@
+// 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";
+/** 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("\n")
+            .filter((l) => l.startsWith("worktree "))
+            .map((l) => l.slice("worktree ".length));
+    }
+    catch {
+        return [];
+    }
+}
+export function removeWorktree(repoRoot, wtPath) {
+    try {
+        git(repoRoot, ["worktree", "remove", "--force", wtPath]);
+    }
+    catch {
+        /* best-effort cleanup */
+    }
+}
+/**
+ * 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 {
+            execFileSync("sh", ["-c", testCmd], { cwd: wt.path, stdio: "pipe" });
+        }
+        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 };
+}
+/** 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("\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 "";
+    }
+}
+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);
+}
+/** 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("\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("\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.
+    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))
+            return { ok: false, reason: `${f} is just main's version — this task's change was dropped` };
+        if (now === 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("\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