@agentsdance/codejury 0.1.2 → 0.1.3

package/README.md

@@ -23,10 +23,14 @@ the target repository; the caller's working tree is not switched or modified.
 
 GitLab and compatible self-hosted services are supported through
 `/merge_requests/<id>` URLs. Jury clones with Git and fetches the standard
-`refs/merge-requests/<id>/head` ref, so existing Git credentials are used. If
+`refs/merge-requests/<id>/head` ref, so existing Git credentials are used.
+When that ref is missing, Jury discovers `refs/merge-requests/<shard>/<id>/<revision>`
+refs and fetches the highest numeric revision, verifying the advertised commit.
+The shard is discovered independently of the MR number. If
 the source branch is not uniquely visible on the target remote (commonly a
 fork), use `--no-push` for a read-only review or check out the source branch
-locally and pass `--dir`.
+locally, omit the MR URL, and run
+`jury --dir /path/to/checkout --trunk <target-branch>`.
 
 Node 20 or newer. The reviewers are separate CLIs you install yourself — `jury` spawns whatever you
 have and skips the rest:
@@ -43,14 +47,17 @@ The former `cr` command remains available as a compatibility alias.
 
 ## Working and state directory
 
-With no `--dir`, Jury keeps the current directory when it is a Git worktree. From anywhere else it
-uses `~/.jury` and creates that directory automatically. An explicitly empty `--dir ""` also selects
-`~/.jury`; a non-empty explicit path always wins. `~` is expanded consistently for review, web,
-runs, findings, and reply commands.
+With an MR/PR URL, Jury always resolves the URL into an isolated checkout. By default,
+checkouts live under `~/.jury/checkouts/` and run records under `~/.jury/runs/`, regardless
+of the current directory. `--dir <path>` instead uses `<path>/checkouts/` and `<path>/runs/`.
+The integrated `--web` console reads records from the same root.
+
+Without a URL, Jury reviews the current repository, or the repository selected by `--dir`.
+Other commands keep the current directory when it is a Git worktree and otherwise use
+`~/.jury`. An explicitly empty `--dir ""` selects `~/.jury`. `~` is expanded consistently.
 
 Run records live in `<dir>/runs`. For example, `jury runs --dir ""` and `jury web --dir ""` read
-`~/.jury/runs`, while a review launched from a repository continues to use that repository's
-`runs` directory.
+`~/.jury/runs`. Use those commands to inspect URL-based reviews launched with the default root.
 
 ## The loop
 

package/bin/jury.js

@@ -533,9 +533,18 @@ async function cmdAgent(argv) {
   }
 
   values.push = values.push && !values["no-push"];
-  const requestedWorktree = await commandDirectory(values.dir);
+  const requestedWorktree = await commandDirectory(values.pr ? (values.dir ?? "") : values.dir);
+  // Two different questions, and conflating them cost the local path entirely.
+  // `root` is where the isolated checkout and run records are written; `dir` is
+  // the repository to resolve the request FROM. A caller sitting in the very
+  // repository under review already has its commits, and asking them for the
+  // one ref the host may have pruned — rather than reading what is on disk —
+  // is what issue #30 was.
+  const resolveFrom = values.dir ? path.resolve(values.dir) : process.cwd();
   const resolved = values.pr
-    ? await resolvePrCheckout(values.pr, { allowPush: values.push, dir: requestedWorktree })
+    ? await resolvePrCheckout(values.pr, {
+      allowPush: values.push, root: requestedWorktree, dir: resolveFrom,
+    })
     : null;
   const worktree = resolved?.worktree ?? requestedWorktree;
   resolvedCheckoutCleanup = resolved?.cleanup ?? null;
@@ -632,7 +641,7 @@ async function cmdAgent(argv) {
   // directory and nothing else: the server re-reads it per request and tails
   // the event log, so it sees each round land without the loop telling it.
   if (values.web) {
-    const { url } = await serve({ port: Number(values.port), onLog: (m) => console.log(st.field("console", st.muted(m))) });
+    const { url } = await serve({ port: Number(values.port), cwd: requestedWorktree, onLog: (m) => console.log(st.field("console", st.muted(m))) });
     liveConsole = url;
     console.log(st.field("console", `${url}${st.muted("  →  the conversation streams live")}`));
     openBrowser(url);

package/lib/repository.js

@@ -122,7 +122,7 @@ class MergeRequestCheckoutError extends Error {}
  *
  * Not every GitLab-compatible host publishes refs/merge-requests/<id>/head.
  * Some expose the individual revisions instead, as
- * refs/merge-requests/<id>/<id>/<revision>, where the highest revision is the
+ * refs/merge-requests/<shard>/<id>/<revision>, where the highest revision is the
  * current head. Returns the advertised sha when that fallback was used, so the
  * caller can check the fetched commit against what the remote said: a request
  * updated mid-fetch would otherwise be reviewed as though it were the head.
@@ -137,18 +137,23 @@ async function fetchMergeRequestHead(exec, worktree, number) {
     // transport failure keeps its own error, or every network problem would be
     // reported as an unusual ref layout.
     if (!/couldn't find remote ref/i.test(String(err.stderr ?? "") + String(err.message))) throw err;
-    const prefix = `refs/merge-requests/${number}/${number}/`;
-    const { stdout } = await exec("git", ["ls-remote", "--refs", "origin", `${prefix}*`], options);
+    // The shard can differ from the MR id (and can contain leading zeroes).
+    // Discover it rather than assuming a particular host's sharding scheme.
+    const { stdout } = await exec("git", ["ls-remote", "--refs", "origin", `refs/merge-requests/*/${number}/*`], options);
     const revisions = String(stdout).split("\n").flatMap((line) => {
       const [sha, ref] = line.trim().split(/\s+/);
-      if (!/^[a-f\d]{40,64}$/i.test(sha ?? "") || !ref?.startsWith(prefix)) return [];
-      const revision = ref.slice(prefix.length);
+      const match = ref?.match(/^refs\/merge-requests\/\d+\/(\d+)\/([1-9]\d*)$/);
+      if (!/^(?:[a-f\d]{40}|[a-f\d]{64})$/i.test(sha ?? "") || match?.[1] !== number) return [];
+      const revision = match[2];
       // Numeric, so revision 10 sorts above revision 9 rather than beside 1.
       return /^[1-9]\d*$/.test(revision) ? [{ sha, ref, revision: BigInt(revision) }] : [];
     });
     revisions.sort((a, b) => (a.revision > b.revision ? -1 : a.revision < b.revision ? 1 : 0));
     if (!revisions.length) throw err; // no revisions either: the original error is the true one
     const latest = revisions[0];
+    if (revisions.some(r => r.revision === latest.revision && r.sha !== latest.sha)) {
+      throw new MergeRequestCheckoutError(`merge request !${number} has conflicting latest revision refs`);
+    }
     await exec("git", ["fetch", "--quiet", "origin", latest.ref], options);
     return latest.sha;
   }
@@ -248,13 +253,13 @@ async function localHead(dir, target, number, { exec, namespace, branch = null }
 }
 
 async function resolveMergeRequestCheckout(prUrl, target, number, {
-  allowPush, exec, makeTemp, remove, dir, home = homedir(),
+  allowPush, exec, makeTemp, remove, dir, root,
 }) {
   // Where the clone lands when one is needed: the same ~/.jury the rest of the
   // CLI already uses, rather than the system temp directory. The checkout is
   // still removed when the review ends — this puts jury's working files under
   // one predictable, inspectable root, and does not make them persist.
-  const worktree = await makeTemp(path.join(home, ".jury", "checkouts", `jury-mr-${number}-`));
+  const worktree = await makeTemp(path.join(root, "checkouts", `jury-mr-${number}-`));
   let advertisedSha = null;
   // Refresh the cached ref before trusting it. A ref fetched before the author
   // pushed again names an obsolete head, and nothing about matching repository
@@ -335,8 +340,8 @@ async function resolveMergeRequestCheckout(prUrl, target, number, {
     }
     if (allowPush && !branch) {
       throw new MergeRequestCheckoutError(
-        `resolved merge request !${number}, but its source branch is not uniquely available on origin — ` +
-        "use --no-push for a read-only review, or check out the source branch and pass --dir",
+        `Can't determine where to push fixes for merge request !${number}.\n` +
+        "Add --no-push to review it without pushing changes.",
       );
     }
 
@@ -352,17 +357,15 @@ async function resolveMergeRequestCheckout(prUrl, target, number, {
   } catch (err) {
     await remove(worktree);
     if (err instanceof MergeRequestCheckoutError) throw err;
-    // git's own words, not a guess. --quiet used to hide them and only the
-    // first line survived, so a pruned head ref — the usual cause — was
-    // reported as a probable authentication problem. Whatever git said is the
-    // one thing that distinguishes the cases.
+    // Preserve the diagnostic even when a connection warning precedes it.
+    // Missing refs alone do not establish whether an MR is open or closed.
     const said = [err.stderr, err.message].map((t) => String(t ?? "").trim()).find(Boolean) ?? "";
     const missingRef = /couldn't find remote ref|no matching remote head/i.test(said);
     throw new Error(
-      `could not resolve ${target.display} merge request !${number}: ${said.split("\n")[0]} — ` +
+      `could not resolve ${target.display} merge request !${number}: ${said}\n` +
       (missingRef
-        ? `${target.host} has no refs/merge-requests/${number}/head; hosts prune it once a request ` +
-          "is merged or old. Check out the source branch and pass --dir."
+        ? "No usable merge request ref was found. Check out the source branch locally, omit the MR URL, " +
+          "and run jury --dir /path/to/checkout --trunk <target-branch>."
         : "check Git authentication and refs/merge-requests support, or check out the source branch and pass --dir"),
     );
   }
@@ -400,13 +403,14 @@ export async function resolvePrCheckout(prUrl, {
   // repository that already holds the request's commits needs no head ref.
   dir = null,
   home = homedir(),
+  root = path.join(home, ".jury"),
 } = {}) {
   const target = repositoryFromPrUrl(prUrl);
   const number = githubNumber(prUrl);
   const mrNumber = mergeRequestNumber(prUrl);
   if (target && mrNumber) {
     return resolveMergeRequestCheckout(prUrl, target, mrNumber, {
-      allowPush, exec, makeTemp, remove, dir, home,
+      allowPush, exec, makeTemp, remove, dir, root,
     });
   }
   if (!target || !number) {
@@ -442,7 +446,7 @@ export async function resolvePrCheckout(prUrl, {
     );
   }
 
-  const worktree = await makeTemp(path.join(home, ".jury", "checkouts", `jury-pr-${number}-`));
+  const worktree = await makeTemp(path.join(root, "checkouts", `jury-pr-${number}-`));
   // `gh` already gave the authoritative head oid, so that — not a cached ref —
   // is what to look for locally. Consulting refs/pull/<id>/head first checked
   // out whatever it pointed at when it was last fetched, which then failed the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentsdance/codejury",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Independent AI reviewers that iterate until your pull request is clean.",
   "keywords": [
     "code-review",