tryharness 0.7.23 → 0.7.25

package/lib/worktrees.mjs

@@ -6,12 +6,25 @@ import { spawnSync } from "node:child_process";
 // at once without touching each other's files or the person's checkout. Each agent turn is committed on the branch,
 // which gives every turn its diff; merge and discard are the person's, never the swarm's.
 
-const IDENTITY = ["-c", "user.name=Harness", "-c", "user.email=harness@localhost"];
+const IDENTITY = [
+  "-c",
+  "user.name=Harness",
+  "-c",
+  "user.email=harness@localhost",
+];
 const PATCH_LIMIT = 200_000;
 
 function git(cwd, args) {
-  const result = spawnSync("git", [...IDENTITY, ...args], { cwd, encoding: "utf8", maxBuffer: 16 * 1024 * 1024 });
-  return { ok: result.status === 0, out: (result.stdout || "").trim(), err: (result.stderr || "").trim() };
+  const result = spawnSync("git", [...IDENTITY, ...args], {
+    cwd,
+    encoding: "utf8",
+    maxBuffer: 16 * 1024 * 1024,
+  });
+  return {
+    ok: result.status === 0,
+    out: (result.stdout || "").trim(),
+    err: (result.stderr || "").trim(),
+  };
 }
 
 /** The repository a folder is in, and the folder's place inside it; null when it is not in one. */
@@ -21,7 +34,10 @@ export function repositoryOf(folder) {
   if (!top.ok || !top.out) return null;
   const head = git(folder, ["rev-parse", "--verify", "HEAD"]);
   if (!head.ok) return null;
-  return { root: fs.realpathSync(top.out), inside: path.relative(fs.realpathSync(top.out), fs.realpathSync(folder)) };
+  return {
+    root: fs.realpathSync(top.out),
+    inside: path.relative(fs.realpathSync(top.out), fs.realpathSync(folder)),
+  };
 }
 
 /**
@@ -31,20 +47,38 @@ export function repositoryOf(folder) {
  */
 export function mainCheckout(folder) {
   if (!folder || !fs.existsSync(folder)) return folder;
-  const found = git(folder, ["rev-parse", "--path-format=absolute", "--show-toplevel", "--git-common-dir"]);
+  const found = git(folder, [
+    "rev-parse",
+    "--path-format=absolute",
+    "--show-toplevel",
+    "--git-common-dir",
+  ]);
   const [top, common] = found.ok ? found.out.split("\n") : [];
   if (!top || !common || path.basename(common) !== ".git") return folder;
   const main = path.dirname(common);
-  if (!fs.existsSync(main) || fs.realpathSync(main) === fs.realpathSync(top)) return folder;
-  return path.join(main, path.relative(fs.realpathSync(top), fs.realpathSync(folder)));
+  if (!fs.existsSync(main) || fs.realpathSync(main) === fs.realpathSync(top))
+    return folder;
+  return path.join(
+    main,
+    path.relative(fs.realpathSync(top), fs.realpathSync(folder))
+  );
 }
 
-const slug = (text) => String(text).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 32) || "thread";
+const slug = (text) =>
+  String(text)
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "")
+    .slice(0, 32) || "thread";
 
 export function createWorktrees({ store, root }) {
   const key = (threadId) => `worktree:${threadId}`;
-  const get = (threadId) => { const raw = store.meta(key(threadId)); return raw ? JSON.parse(raw) : null; };
-  const save = (threadId, value) => store.meta(key(threadId), value ? JSON.stringify(value) : "null");
+  const get = (threadId) => {
+    const raw = store.meta(key(threadId));
+    return raw ? JSON.parse(raw) : null;
+  };
+  const save = (threadId, value) =>
+    store.meta(key(threadId), value ? JSON.stringify(value) : "null");
 
   /** Where a thread's coding runs work: its worktree when the folder is in a repository, else the folder itself. */
   const folderFor = (thread) => {
@@ -52,27 +86,54 @@ export function createWorktrees({ store, root }) {
     if (!folder) return null;
     const current = get(thread.id);
     if (current?.state === "in_place") return folder;
-    if (current?.state === "t3") return current.path && fs.existsSync(current.path) ? current.path : folder;
-    if (current && current.state === "open" && fs.existsSync(current.path)) return path.join(current.path, current.inside);
+    if (current?.state === "t3")
+      return current.path && fs.existsSync(current.path)
+        ? current.path
+        : folder;
+    if (current && current.state === "open" && fs.existsSync(current.path))
+      return path.join(current.path, current.inside);
     const repo = repositoryOf(folder);
     if (!repo) return folder;
     const where = path.join(root, thread.id);
     const branch = `harness/${slug(thread.objective)}-${thread.id.slice(0, 8)}`;
     const base = git(repo.root, ["rev-parse", "HEAD"]).out;
     fs.mkdirSync(root, { recursive: true });
-    const added = git(repo.root, ["worktree", "add", "-b", branch, where, base]);
-    if (!added.ok) throw new Error(`could not make the thread's copy of ${repo.root}: ${added.err}`);
-    save(thread.id, { state: "open", repo: repo.root, inside: repo.inside, path: where, branch, base });
+    const added = git(repo.root, [
+      "worktree",
+      "add",
+      "-b",
+      branch,
+      where,
+      base,
+    ]);
+    if (!added.ok)
+      throw new Error(
+        `could not make the thread's copy of ${repo.root}: ${added.err}`
+      );
+    save(thread.id, {
+      state: "open",
+      repo: repo.root,
+      inside: repo.inside,
+      path: where,
+      branch,
+      base,
+    });
     return path.join(where, repo.inside);
   };
 
   /** Commits what a turn changed on the thread's branch; the commit is that turn's diff. Null when nothing changed. */
   const commitTurn = (threadId, runId, message) => {
     const tree = get(threadId);
-    if (!tree || tree.state !== "open" || !fs.existsSync(tree.path)) return null;
+    if (!tree || tree.state !== "open" || !fs.existsSync(tree.path))
+      return null;
     git(tree.path, ["add", "-A"]);
     if (git(tree.path, ["diff", "--cached", "--quiet"]).ok) return null;
-    const committed = git(tree.path, ["commit", "-q", "-m", String(message).slice(0, 200)]);
+    const committed = git(tree.path, [
+      "commit",
+      "-q",
+      "-m",
+      String(message).slice(0, 200),
+    ]);
     if (!committed.ok) return null;
     const sha = git(tree.path, ["rev-parse", "HEAD"]).out;
     store.meta(`turn:${runId}`, sha);
@@ -81,30 +142,53 @@ export function createWorktrees({ store, root }) {
 
   const stat = (cwd, range) => {
     const out = git(cwd, ["diff", "--numstat", range]).out;
-    const files = out ? out.split("\n").map((line) => { const [added, removed, file] = line.split("\t"); return { file, added: Number(added) || 0, removed: Number(removed) || 0 }; }) : [];
+    const files = out
+      ? out.split("\n").map((line) => {
+          const [added, removed, file] = line.split("\t");
+          return {
+            file,
+            added: Number(added) || 0,
+            removed: Number(removed) || 0,
+          };
+        })
+      : [];
     return files;
   };
 
   /** What a thread changed: everything since it began, or one turn's commit. */
   const diff = (threadId, runId = null) => {
     const tree = get(threadId);
-    if (!tree) return { ok: false, error: "this thread has no copy of a repository" };
+    if (!tree)
+      return { ok: false, error: "this thread has no copy of a repository" };
     const cwd = fs.existsSync(tree.path) ? tree.path : tree.repo;
     let range;
     if (runId) {
       const sha = store.meta(`turn:${runId}`);
       if (!sha) return { ok: true, files: [], patch: "" };
       range = `${sha}~1..${sha}`;
-    } else range = `${tree.base}..${tree.state === "open" ? "HEAD" : tree.branch}`;
+    } else
+      range = `${tree.base}..${tree.state === "open" ? "HEAD" : tree.branch}`;
     const patch = git(cwd, ["diff", range]).out;
-    return { ok: true, files: stat(cwd, range), patch: patch.length > PATCH_LIMIT ? `${patch.slice(0, PATCH_LIMIT)}\n… (cut here; the rest is on branch ${tree.branch})` : patch, branch: tree.branch, state: tree.state };
+    return {
+      ok: true,
+      files: stat(cwd, range),
+      patch:
+        patch.length > PATCH_LIMIT
+          ? `${patch.slice(0, PATCH_LIMIT)}\n… (cut here; the rest is on branch ${tree.branch})`
+          : patch,
+      branch: tree.branch,
+      state: tree.state,
+    };
   };
 
   const summary = (threadId) => {
     const tree = get(threadId);
     // A thread T3 Code works in keeps its changes in T3's own checkout, where T3 shows and merges them.
     if (!tree || tree.state === "in_place" || tree.state === "t3") return null;
-    const files = tree.state === "open" && fs.existsSync(tree.path) ? stat(tree.path, `${tree.base}..HEAD`).length : 0;
+    const files =
+      tree.state === "open" && fs.existsSync(tree.path)
+        ? stat(tree.path, `${tree.base}..HEAD`).length
+        : 0;
     return { state: tree.state, branch: tree.branch, repo: tree.repo, files };
   };
 
@@ -116,26 +200,54 @@ export function createWorktrees({ store, root }) {
   /** Brings the thread's branch into the branch the person has checked out. A conflict is undone and reported. */
   const merge = (threadId, title) => {
     const tree = get(threadId);
-    if (!tree || tree.state !== "open") return { ok: false, error: "there is nothing of this thread's to merge" };
-    if (!stat(tree.path, `${tree.base}..HEAD`).length) return { ok: false, error: "this thread has not changed anything" };
+    if (!tree || tree.state !== "open")
+      return { ok: false, error: "there is nothing of this thread's to merge" };
+    if (!stat(tree.path, `${tree.base}..HEAD`).length)
+      return { ok: false, error: "this thread has not changed anything" };
     const into = git(tree.repo, ["rev-parse", "--abbrev-ref", "HEAD"]).out;
-    const merged = git(tree.repo, ["merge", "--no-ff", "-m", `Merge ${tree.branch}: ${String(title).slice(0, 120)}`, tree.branch]);
+    const merged = git(tree.repo, [
+      "merge",
+      "--no-ff",
+      "-m",
+      `Merge ${tree.branch}: ${String(title).slice(0, 120)}`,
+      tree.branch,
+    ]);
     if (!merged.ok) {
-      const conflicts = git(tree.repo, ["diff", "--name-only", "--diff-filter=U"]).out.split("\n").filter(Boolean);
+      const conflicts = git(tree.repo, [
+        "diff",
+        "--name-only",
+        "--diff-filter=U",
+      ])
+        .out.split("\n")
+        .filter(Boolean);
       git(tree.repo, ["merge", "--abort"]);
-      return { ok: false, conflict: true, files: conflicts, error: conflicts.length
-        ? `merging into ${into} conflicts in ${conflicts.join(", ")}; nothing was merged`
-        : `git would not merge into ${into}: ${merged.err.split("\n")[0]}; nothing was merged` };
+      return {
+        ok: false,
+        conflict: true,
+        files: conflicts,
+        error: conflicts.length
+          ? `merging into ${into} conflicts in ${conflicts.join(", ")}; nothing was merged`
+          : `git would not merge into ${into}: ${merged.err.split("\n")[0]}; nothing was merged`,
+      };
     }
     retire(tree);
     git(tree.repo, ["branch", "-d", tree.branch]);
-    save(threadId, { ...tree, state: "merged", into, mergedAt: new Date().toISOString() });
+    save(threadId, {
+      ...tree,
+      state: "merged",
+      into,
+      mergedAt: new Date().toISOString(),
+    });
     return { ok: true, into };
   };
 
   const discard = (threadId) => {
     const tree = get(threadId);
-    if (!tree || tree.state !== "open") return { ok: false, error: "there is nothing of this thread's to discard" };
+    if (!tree || tree.state !== "open")
+      return {
+        ok: false,
+        error: "there is nothing of this thread's to discard",
+      };
     retire(tree);
     git(tree.repo, ["branch", "-D", tree.branch]);
     save(threadId, { ...tree, state: "discarded" });
@@ -149,7 +261,11 @@ export function createWorktrees({ store, root }) {
   const moved = (threadId) => {
     const tree = get(threadId);
     if (tree?.state === "open" && fs.existsSync(tree.path)) {
-      if (stat(tree.path, `${tree.base}..HEAD`).length) return { ok: false, error: `this thread changed files on ${tree.branch}; merge or discard them first` };
+      if (stat(tree.path, `${tree.base}..HEAD`).length)
+        return {
+          ok: false,
+          error: `this thread changed files on ${tree.branch}; merge or discard them first`,
+        };
       retire(tree);
       git(tree.repo, ["branch", "-D", tree.branch]);
     }
@@ -168,19 +284,51 @@ export function createWorktrees({ store, root }) {
    */
   const t3Workspace = (thread) => {
     const current = get(thread.id);
-    if (current?.state === "in_place" || current?.inPlace) return { type: "root" };
-    if ((current?.state === "t3" || current?.state === "open") && current.path) return { type: "existing_worktree", worktreePath: current.path, ...(current.branch ? { branch: current.branch } : {}) };
+    if (current?.state === "in_place" || current?.inPlace)
+      return { type: "root" };
+    if ((current?.state === "t3" || current?.state === "open") && current.path)
+      return {
+        type: "existing_worktree",
+        worktreePath: current.path,
+        ...(current.branch ? { branch: current.branch } : {}),
+      };
     const repo = repositoryOf(thread.goal.workspace);
     if (!repo) return { type: "root" };
     const branch = git(repo.root, ["rev-parse", "--abbrev-ref", "HEAD"]).out;
-    return { type: "worktree", baseRef: branch && branch !== "HEAD" ? branch : git(repo.root, ["rev-parse", "HEAD"]).out,
-      branch: `harness/${slug(thread.objective)}-${thread.id.slice(0, 8)}`, startFromOrigin: false };
+    return {
+      type: "worktree",
+      baseRef:
+        branch && branch !== "HEAD"
+          ? branch
+          : git(repo.root, ["rev-parse", "HEAD"]).out,
+      branch: `harness/${slug(thread.objective)}-${thread.id.slice(0, 8)}`,
+      startFromOrigin: false,
+    };
   };
   /** The thread works in T3 Code from now on; `where` and `branch` once T3 has made its checkout. */
   const inT3 = (threadId, where = null, branch = null) => {
     const current = get(threadId);
-    if (current?.state !== "t3" || (where && where !== current.path)) save(threadId, { ...current, ...(current?.state === "in_place" ? { inPlace: true } : {}), state: "t3", path: where ?? current?.path ?? null, branch: branch ?? current?.branch ?? null });
+    if (current?.state !== "t3" || (where && where !== current.path))
+      save(threadId, {
+        ...current,
+        ...(current?.state === "in_place" ? { inPlace: true } : {}),
+        state: "t3",
+        path: where ?? current?.path ?? null,
+        branch: branch ?? current?.branch ?? null,
+      });
   };
 
-  return { folderFor, commitTurn, diff, summary, merge, discard, moved, inPlace, t3Workspace, inT3, get };
+  return {
+    folderFor,
+    commitTurn,
+    diff,
+    summary,
+    merge,
+    discard,
+    moved,
+    inPlace,
+    t3Workspace,
+    inT3,
+    get,
+  };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tryharness",
-  "version": "0.7.23",
+  "version": "0.7.25",
   "description": "Harness Relay: the daemon that turns the agents on this machine into your personal swarm. Memory, history, and work handed between any of them.",
   "bin": {
     "tryharness": "cli.mjs"
@@ -41,8 +41,8 @@
     "ws": "^8.18.3"
   },
   "optionalDependencies": {
-    "tryharness-desktop-darwin-arm64": "0.7.23",
-    "tryharness-desktop-darwin-x64": "0.7.23",
+    "tryharness-desktop-darwin-arm64": "0.7.25",
+    "tryharness-desktop-darwin-x64": "0.7.25",
     "tryharness-desktop-linux-x64": "0.7.4",
     "tryharness-desktop-win32-x64": "0.7.4"
   }