@maycombhq/atticus 2.0.0-beta.2 → 2.0.0-beta.22

package/dist/{chunk-BWZ77RQT.js → chunk-PAQ2AS5E.js}

@@ -5,7 +5,7 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   runtimeForCli
-} from "./chunk-CNUKCS2T.js";
+} from "./chunk-P32RUW3B.js";
 
 // packages/cli/dist/judging.js
 async function judgingRuntime(root, given) {

package/dist/{chunk-ZMAINWBW.js → chunk-PBPBMP2B.js}

@@ -7,9 +7,10 @@ import {
   ME_FILE,
   readMe,
   writeMe
-} from "./chunk-JBTK5OP2.js";
-import "./chunk-S2A7YC3Q.js";
-import "./chunk-D3PO4DOZ.js";
+} from "./chunk-2Q56PQPS.js";
+import "./chunk-Q2TECDIT.js";
+import "./chunk-TUULXQRW.js";
+import "./chunk-BQGDB6ZL.js";
 import "./chunk-TV45EUGM.js";
 export {
   ME_FILE,

package/dist/{chunk-ZVM6AKKM.js → chunk-PJSJPMJI.js}

@@ -9,7 +9,7 @@ import {
   namesInCode,
   openIndex,
   workspaceRepos
-} from "./chunk-T6AIP7H5.js";
+} from "./chunk-ISUAAMGS.js";
 
 // packages/cli/dist/code-tools.js
 var offered = /* @__PURE__ */ new Map();
@@ -21,7 +21,7 @@ function codeToolOptions(root) {
     codeDir: (r) => offered.get(r) ?? defaultCodeDir(root, r),
     repos: () => [.../* @__PURE__ */ new Set([...workspaceRepos(root), ...offered.keys()])].sort(),
     // Loaded on first use: the readers are large, and most commands never outline a file.
-    outline: async (path, text) => (await import("./chunk-MMOSZPWJ.js")).declarationOutline(path, text)
+    outline: async (path, text) => (await import("./chunk-H5HBGNXU.js")).declarationOutline(path, text)
   };
 }
 function metarepoToolBox(root, calls) {
@@ -31,7 +31,7 @@ function metarepoToolBox(root, calls) {
   });
 }
 async function criticCodeSearch(root, names) {
-  const x = await import("./chunk-MMOSZPWJ.js");
+  const x = await import("./chunk-H5HBGNXU.js");
   const r = await namesInCode(root, names, {
     ...codeToolOptions(root),
     outlines: (path) => x.syntaxLanguageOf(path) !== void 0

package/dist/{chunk-EFHQ3TWP.js → chunk-PKBHS4AA.js}

@@ -11,10 +11,15 @@ import {
   changeBranch,
   changesDirOf,
   orgPackDirOf,
-  require_dist,
   runsDirOf,
   toCanonicalYaml
-} from "./chunk-S2A7YC3Q.js";
+} from "./chunk-Q2TECDIT.js";
+import {
+  withSharedFileLock
+} from "./chunk-TUULXQRW.js";
+import {
+  require_dist
+} from "./chunk-BQGDB6ZL.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";
@@ -40,8 +45,9 @@ function createGit(opts = {}) {
     GIT_PAGER: "cat",
     LC_ALL: "C"
   };
+  const pre = process.platform === "win32" ? ["-c", "core.longpaths=true"] : [];
   return (args, cwd) => new Promise((resolve, reject) => {
-    execFile("git", args, {
+    execFile("git", [...pre, ...args], {
       cwd,
       env,
       timeout: opts.timeoutMs ?? 10 * 6e4,
@@ -70,23 +76,26 @@ var STATUS = {
   T: "type-changed"
 };
 async function changedFiles(dir, from, to, git = createGit({ timeoutMs: 6e4 })) {
-  const r = await git(["diff", "--name-status", "-M", "-z", "--no-color", "--no-ext-diff", from, to, "--"], dir);
+  const r = await git(["diff", "--raw", "--no-abbrev", "-M", "-z", "--no-color", "--no-ext-diff", from, to, "--"], dir);
   const parts = r.stdout.split("\0");
   const out = [];
   for (let i = 0; i < parts.length; ) {
-    const code = parts[i++] ?? "";
-    if (!code)
+    const head = parts[i++] ?? "";
+    if (!head)
       continue;
-    const status = STATUS[code[0]];
+    const [oldMode, newMode, , , code = ""] = head.replace(/^:/, "").split(" ");
+    const gitlink = oldMode === "160000" || newMode === "160000";
+    const link = gitlink ? { gitlink: true } : {};
+    const status = STATUS[code[0] ?? ""];
     if (status === "renamed" || status === "copied") {
       const old = parts[i++] ?? "";
       const path = parts[i++] ?? "";
       if (old && path)
-        out.push({ status, path, from: old });
+        out.push({ status, path, from: old, ...link });
     } else {
       const path = parts[i++] ?? "";
       if (path)
-        out.push({ status: status ?? "modified", path });
+        out.push({ status: status ?? "modified", path, ...link });
     }
   }
   return out.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
@@ -97,6 +106,7 @@ async function changesSince(dir, commits, to, git) {
   const missing = [];
   for (const c of [...new Set(commits)].filter((x) => !sameCommit(x, to)).sort()) {
     try {
+      await (git ?? createGit({ timeoutMs: 6e4 }))(["merge-base", "--is-ancestor", c, to], dir);
       changes[c] = await changedFiles(dir, c, to, git);
     } catch {
       missing.push(c);
@@ -106,6 +116,7 @@ async function changesSince(dir, commits, to, git) {
 }
 
 // packages/workspace/dist/layout.js
+import { createHash } from "node:crypto";
 import { readFile, writeFile } from "node:fs/promises";
 import { join, relative, sep } from "node:path";
 var WORKSPACE_DIR = "workspace";
@@ -118,10 +129,20 @@ function id(what, value) {
 function baseClonePath(root, repo) {
   return join(root, WORKSPACE_DIR, id("repo id", repo));
 }
-var branchSlug = (branch) => branch.replace(/[^A-Za-z0-9.-]+/g, "-");
+var legacyBranchSlug = (branch) => branch.replace(/[^A-Za-z0-9.-]+/g, "-");
+var branchSlug = (branch) => {
+  const s = legacyBranchSlug(branch);
+  if (!/[A-Z]/.test(s))
+    return s;
+  const hash = createHash("sha256").update(branch, "utf8").digest("hex").slice(0, 8);
+  return `${s.toLowerCase()}-${hash}`;
+};
 function branchCheckoutPath(root, repo, branch) {
   return join(root, WORKSPACE_DIR, ".branches", id("repo id", repo), branchSlug(branch));
 }
+function legacyBranchCheckoutPath(root, repo, branch) {
+  return join(root, WORKSPACE_DIR, ".branches", id("repo id", repo), legacyBranchSlug(branch));
+}
 function changeWorktreesDir(root, change) {
   return join(root, WORKSPACE_DIR, ".worktrees", id("change id", change));
 }
@@ -244,7 +265,7 @@ async function writeChangeRepos(root, value) {
 
 // packages/workspace/dist/editors.js
 import { existsSync } from "node:fs";
-import { mkdir as mkdir2, rm, writeFile as writeFile3 } from "node:fs/promises";
+import { mkdir as mkdir2, readdir as readdir2, rm, writeFile as writeFile3 } from "node:fs/promises";
 import { join as join3, relative as relative2, sep as sep2 } from "node:path";
 var posix = (p) => p.split(sep2).join("/");
 function xmlEscape(s) {
@@ -329,9 +350,12 @@ async function writeEditorWorkspaces(root, repos) {
   await writeFile3(vscode, JSON.stringify(vscodeWorkspace(root, repos), null, 2) + "\n", "utf8");
   const intellij = intellijProjectPath(root, repos.change);
   const ideaDir = join3(intellij, ".idea");
-  await rm(ideaDir, { recursive: true, force: true });
   await mkdir2(ideaDir, { recursive: true });
-  for (const [name, text] of Object.entries(intellijProject(root, repos))) {
+  const files = intellijProject(root, repos);
+  for (const name of await readdir2(ideaDir).catch(() => []))
+    if (name.endsWith(".iml") && !(name in files))
+      await rm(join3(ideaDir, name), { force: true });
+  for (const [name, text] of Object.entries(files)) {
     await writeFile3(join3(ideaDir, name), text, "utf8");
   }
   return { vscode, intellij };
@@ -350,10 +374,32 @@ async function checkoutState(dir, git = createGit()) {
 
 // packages/workspace/dist/manager.js
 import { existsSync as existsSync2 } from "node:fs";
-import { mkdir as mkdir3, rm as rm2 } from "node:fs/promises";
-import { dirname as dirname2 } from "node:path";
+import { mkdir as mkdir3, readdir as readdir3, rm as rm2 } from "node:fs/promises";
+import { basename, dirname as dirname2, join as join4 } from "node:path";
+function withBaseClone(dest, id2, work) {
+  return withSharedFileLock(dest, work, {
+    staleMs: 30 * 6e4,
+    waitMs: 30 * 6e4,
+    what: `git work on the base clone of ${id2}`
+  });
+}
 function isInPlace(url) {
-  return url === "." || url.startsWith("./");
+  const u = url.replace(/\\/g, "/");
+  return u === "." || u.startsWith("./");
+}
+function inPlacePath(url) {
+  if (!isInPlace(url))
+    return void 0;
+  const segs = url.split(/[\\/]+/).filter((s) => s !== "" && s !== ".");
+  if (segs.includes(".."))
+    return void 0;
+  return segs.length ? segs.join("/") : ".";
+}
+function inPlaceDir(root, url) {
+  const p = inPlacePath(url);
+  if (p === void 0)
+    return void 0;
+  return p === "." ? root : join4(root, ...p.split("/"));
 }
 async function remoteDefaultBranch(dir, git = createGit()) {
   if (!existsSync2(dir))
@@ -385,7 +431,44 @@ function createWorkspace(root, git = createGit()) {
     const b = await remoteDefaultBranch(cwd, git);
     return b ? { remoteDefault: b } : {};
   };
-  async function syncOne(repo) {
+  async function copyFrom(repo, from, dest) {
+    const branch = repo.defaultBranch;
+    const sha = async (ref) => {
+      try {
+        return (await g(["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], from)).stdout.trim();
+      } catch {
+        return "";
+      }
+    };
+    const at = await sha(`refs/remotes/origin/${branch}`) || await sha(`refs/heads/${branch}`);
+    if (!at)
+      return {
+        id: repo.id,
+        action: "failed",
+        reason: `your clone at ${from} has no ${branch} branch; fetch it there, or sync without --from`
+      };
+    await g([
+      "clone",
+      "-c",
+      "core.longpaths=true",
+      "--quiet",
+      "--no-tags",
+      "--no-checkout",
+      "--",
+      from,
+      dest
+    ]);
+    await g(["remote", "set-url", "origin", "--", repo.url], dest);
+    const refs = (await g(["for-each-ref", "--format=%(refname)", "refs/remotes/origin"], dest)).stdout.split("\n").filter(Boolean);
+    for (const r of refs)
+      await g(["update-ref", "-d", r], dest);
+    await g(["update-ref", `refs/remotes/origin/${branch}`, at], dest);
+    if (repo.sparse.length > 0)
+      await g(["sparse-checkout", "set", "--", ...repo.sparse], dest);
+    await g(["checkout", "--quiet", "-B", branch, at], dest);
+    return { id: repo.id, action: "cloned", sha: await head(dest), from };
+  }
+  async function syncOne(repo, local) {
     if (repo.archived)
       return { id: repo.id, action: "skipped", reason: "archived" };
     if (isInPlace(repo.url))
@@ -396,10 +479,22 @@ function createWorkspace(root, git = createGit()) {
       };
     const dest = baseClonePath(root, repo.id);
     const branch = repo.defaultBranch;
+    const made = !existsSync2(dest);
     try {
-      if (!existsSync2(dest)) {
+      if (made) {
         await mkdir3(dirname2(dest), { recursive: true });
-        const args = ["clone", "--no-tags", "--branch", branch, "--filter=blob:none"];
+        const from = local && yourClone(local, repo);
+        if (from)
+          return await copyFrom(repo, from, dest);
+        const args = [
+          "clone",
+          "-c",
+          "core.longpaths=true",
+          "--no-tags",
+          "--branch",
+          branch,
+          "--filter=blob:none"
+        ];
         if (repo.sparse.length > 0)
           args.push("--sparse");
         args.push("--", repo.url, dest);
@@ -432,7 +527,14 @@ function createWorkspace(root, git = createGit()) {
         ...await remoteDefault(dest)
       };
     } catch (err) {
-      return { id: repo.id, action: "failed", reason: err.message };
+      if (made)
+        await rm2(dest, { recursive: true, force: true }).catch(() => void 0);
+      const msg = err.message;
+      return {
+        id: repo.id,
+        action: "failed",
+        reason: /Filename too long/i.test(msg) ? `${msg.trim()} \u2014 a path in the repo is longer than Windows allows: run git config --global core.longpaths true, then sync again` : msg
+      };
     }
   }
   async function worktreeFor(change, repo) {
@@ -466,40 +568,53 @@ function createWorkspace(root, git = createGit()) {
       build: { status: "not-run" }
     };
   }
+  async function checkoutOne(repo, branch) {
+    const base = baseClonePath(root, repo.id);
+    if (!existsSync2(base))
+      throw new Error(`no base clone for ${repo.id}; run atticus workspace sync first`);
+    const ref = `refs/remotes/origin/${branch}`;
+    try {
+      await g(["fetch", "--no-tags", "origin", `+refs/heads/${branch}:${ref}`], base);
+    } catch {
+      throw new Error(`${repo.id} has no branch ${branch} on its remote`);
+    }
+    const dir = branchCheckoutPath(root, repo.id, branch);
+    const old = legacyBranchCheckoutPath(root, repo.id, branch);
+    if (old !== dir && !existsSync2(dir) && existsSync2(old))
+      await g(["worktree", "move", "--", old, dir], base).catch(() => void 0);
+    if (!existsSync2(dir)) {
+      await mkdir3(dirname2(dir), { recursive: true });
+      await g(["worktree", "add", "--detach", "--", dir, ref], base);
+    } else {
+      if (await dirty(dir))
+        throw new Error(`${repo.id}'s checkout of ${branch} has local changes: commit or stash them in ${dir}, then try again`);
+      await g(["checkout", "--quiet", "--force", "--detach", ref], dir);
+    }
+    return { dir, commit: await head(dir) };
+  }
   return {
     root,
-    async sync(repos) {
+    async sync(repos, opts = {}) {
       if (repos.some((r) => !r.archived && !isInPlace(r.url)))
         await ensureGitignore(root);
       const out = [];
+      const local = opts.from ? await localClones(opts.from, git) : void 0;
       for (const repo of repos)
-        out.push(await syncOne(repo));
+        out.push(
+          // Nothing to lock (nor a folder to make) for an archived or in-place repo.
+          repo.archived || isInPlace(repo.url) ? await syncOne(repo, local) : await withBaseClone(baseClonePath(root, repo.id), repo.id, () => syncOne(repo, local))
+        );
       return out;
     },
-    async checkoutBranch(repo, branch) {
-      const base = baseClonePath(root, repo.id);
-      if (!existsSync2(base))
-        throw new Error(`no base clone for ${repo.id}; run atticus workspace sync first`);
-      const ref = `refs/remotes/origin/${branch}`;
-      try {
-        await g(["fetch", "--no-tags", "origin", `+refs/heads/${branch}:${ref}`], base);
-      } catch {
-        throw new Error(`${repo.id} has no branch ${branch} on its remote`);
-      }
-      const dir = branchCheckoutPath(root, repo.id, branch);
-      if (!existsSync2(dir)) {
-        await mkdir3(dirname2(dir), { recursive: true });
-        await g(["worktree", "add", "--detach", "--", dir, ref], base);
-      } else
-        await g(["checkout", "--quiet", "--force", "--detach", ref], dir);
-      return { dir, commit: await head(dir) };
+    checkoutBranch(repo, branch) {
+      return withBaseClone(baseClonePath(root, repo.id), repo.id, () => checkoutOne(repo, branch));
     },
     async openChange(change, repos) {
       await ensureGitignore(root);
       const existing = await readChangeRepos(root, change);
       const byId = new Map((existing?.repos ?? []).map((r) => [r.id, r]));
       for (const repo of repos) {
-        const fresh = await worktreeFor(change, repo);
+        const fresh = await withBaseClone(baseClonePath(root, repo.id), repo.id, () => worktreeFor(change, repo));
         const prior = byId.get(repo.id);
         byId.set(repo.id, prior ? { ...fresh, ...prior, worktree: fresh.worktree } : fresh);
       }
@@ -518,10 +633,27 @@ function createWorkspace(root, git = createGit()) {
       const kept = [];
       if (!repos)
         return { removed, kept };
+      const removeOne = async (id2, path, repo) => {
+        try {
+          if (!opts.force && await dirty(path)) {
+            kept.push({ id: id2, reason: "uncommitted changes in the worktree" });
+            return;
+          }
+          const args = ["worktree", "remove"];
+          if (opts.force)
+            args.push("--force");
+          await g([...args, "--", path], baseClonePath(root, repo));
+          removed.push(id2);
+        } catch (err) {
+          kept.push({ id: id2, reason: err instanceof GitError ? err.message : String(err) });
+        }
+      };
+      const waiting = /* @__PURE__ */ new Set();
       for (const r of repos.repos) {
         const done = r.pr?.state === "merged" || r.pr?.state === "closed";
         if (!done && !opts.all) {
           kept.push({ id: r.id, reason: r.pr ? `PR is ${r.pr.state}` : "no PR yet" });
+          waiting.add(r.id);
           continue;
         }
         const path = worktreePath(root, change, r.id);
@@ -529,24 +661,27 @@ function createWorkspace(root, git = createGit()) {
           removed.push(r.id);
           continue;
         }
-        const base = baseClonePath(root, r.id);
-        try {
-          if (!opts.force && await dirty(path)) {
-            kept.push({ id: r.id, reason: "uncommitted changes in the worktree" });
+        await removeOne(r.id, path, r.id);
+      }
+      const tasksDir = join4(changeWorktreesDir(root, change), ".tasks");
+      const subdirs = async (dir) => (await readdir3(dir, { withFileTypes: true }).catch(() => [])).filter((d) => d.isDirectory()).map((d) => d.name).sort();
+      const taskRepos = /* @__PURE__ */ new Set();
+      for (const task of await subdirs(tasksDir))
+        for (const repo of await subdirs(join4(tasksDir, task))) {
+          taskRepos.add(repo);
+          if (waiting.has(repo))
             continue;
-          }
-          const args = ["worktree", "remove"];
-          if (opts.force)
-            args.push("--force");
-          await g([...args, "--", path], base);
-          removed.push(r.id);
-        } catch (err) {
-          kept.push({ id: r.id, reason: err instanceof GitError ? err.message : String(err) });
+          await removeOne(`${repo} task ${task}`, join4(tasksDir, task, repo), repo);
         }
-      }
-      for (const r of repos.repos) {
-        if (existsSync2(baseClonePath(root, r.id)))
-          await g(["worktree", "prune"], baseClonePath(root, r.id)).catch(() => void 0);
+      for (const id2 of /* @__PURE__ */ new Set([...repos.repos.map((r) => r.id), ...taskRepos])) {
+        let base;
+        try {
+          base = baseClonePath(root, id2);
+        } catch {
+          continue;
+        }
+        if (existsSync2(base))
+          await g(["worktree", "prune"], base).catch(() => void 0);
       }
       if (kept.length === 0) {
         await removeEditorWorkspaces(root, change);
@@ -556,6 +691,44 @@ function createWorkspace(root, git = createGit()) {
     }
   };
 }
+function remoteKey(url) {
+  let u = url.trim().replace(/\\/g, "/");
+  const scp = /^[\w.-]+@([^:/]+):(.+)$/.exec(u);
+  if (scp)
+    u = `${scp[1]}/${scp[2]}`;
+  u = u.replace(/^[a-z+]+:\/\//i, "").replace(/^[^@/]+@/, "");
+  u = u.replace(/\/{2,}/g, "/").replace(/\/+$/, "").replace(/\.git$/i, "");
+  const slash = u.indexOf("/");
+  return slash < 0 ? u.toLowerCase() : u.slice(0, slash).toLowerCase() + u.slice(slash);
+}
+async function localClones(dir, g) {
+  const found = /* @__PURE__ */ new Map();
+  const visit = async (d, depth) => {
+    let names;
+    try {
+      names = await readdir3(d);
+    } catch {
+      return;
+    }
+    if (names.includes(".git")) {
+      const url = await g(["config", "--get", "remote.origin.url"], d).then((r) => r.stdout.trim(), () => "");
+      if (url && !found.has(`url:${remoteKey(url)}`))
+        found.set(`url:${remoteKey(url)}`, d);
+      if (!found.has(`name:${nameKey(basename(d))}`))
+        found.set(`name:${nameKey(basename(d))}`, d);
+      return;
+    }
+    if (depth === 0)
+      return;
+    for (const n of names)
+      if (!n.startsWith(".") && n !== "node_modules")
+        await visit(join4(d, n), depth - 1);
+  };
+  await visit(dir, 2);
+  return found;
+}
+var yourClone = (local, repo) => local.get(`url:${remoteKey(repo.url)}`) ?? local.get(`name:${nameKey(repo.id)}`);
+var nameKey = (s) => s.toLowerCase().replace(/[^a-z0-9._-]+/g, "-");
 
 // packages/workspace/dist/identity.js
 import { userInfo } from "node:os";
@@ -609,8 +782,10 @@ export {
   WORKSPACE_DIR,
   IGNORED,
   baseClonePath,
+  legacyBranchSlug,
   branchSlug,
   branchCheckoutPath,
+  legacyBranchCheckoutPath,
   changeWorktreesDir,
   worktreePath,
   changeDir,
@@ -630,6 +805,8 @@ export {
   removeEditorWorkspaces,
   checkoutState,
   isInPlace,
+  inPlacePath,
+  inPlaceDir,
   remoteDefaultBranch,
   createWorkspace,
   toHandle,

package/dist/{chunk-GT4I4ZWM.js → chunk-PMUAJGLI.js}

@@ -4,31 +4,35 @@ var require = __atticusCreateRequire(import.meta.url);
 var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
+  completeCriticBatch,
   completeCriticLens,
   critic,
   criticStats,
   findingAction,
   findings,
   statusLine
-} from "./chunk-6M5NK3K3.js";
+} from "./chunk-UF4AZOZB.js";
 import "./chunk-VOGCSYOI.js";
-import "./chunk-3HI6Z55Y.js";
-import "./chunk-XY3P7JW7.js";
-import "./chunk-4AK7IBVP.js";
-import "./chunk-7JUKDRSZ.js";
-import "./chunk-27NKUS3X.js";
-import "./chunk-L24C55VN.js";
-import "./chunk-PAMPPUR6.js";
-import "./chunk-23W7VWKR.js";
-import "./chunk-7EKXJZ2Y.js";
-import "./chunk-MC3H7736.js";
-import "./chunk-EFHQ3TWP.js";
-import "./chunk-GQ4N4WKF.js";
-import "./chunk-CNUKCS2T.js";
-import "./chunk-S2A7YC3Q.js";
-import "./chunk-D3PO4DOZ.js";
+import "./chunk-S4PMJU6H.js";
+import "./chunk-IDKCWSM5.js";
+import "./chunk-UUU4CLJG.js";
+import "./chunk-7IGKHZ4Z.js";
+import "./chunk-J2JAKCIW.js";
+import "./chunk-745DAZ4L.js";
+import "./chunk-CXJ6FUKN.js";
+import "./chunk-QKUJMING.js";
+import "./chunk-6ZGLAACW.js";
+import "./chunk-CQDGOPGH.js";
+import "./chunk-3NFFJL5D.js";
+import "./chunk-PKBHS4AA.js";
+import "./chunk-P32RUW3B.js";
+import "./chunk-QA4O2GGC.js";
+import "./chunk-Q2TECDIT.js";
+import "./chunk-TUULXQRW.js";
+import "./chunk-BQGDB6ZL.js";
 import "./chunk-TV45EUGM.js";
 export {
+  completeCriticBatch,
   completeCriticLens,
   critic,
   criticStats,