@maycombhq/atticus 0.0.0-stage → 2.0.0-beta.3

package/dist/chunk-KJPMEAI4.js

@@ -0,0 +1,705 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  ChangeRepos,
+  RecordId,
+  RepoManifest,
+  WORKSPACE_SCHEMA_VERSION,
+  changeBranch,
+  changesDirOf,
+  orgPackDirOf,
+  require_dist,
+  runsDirOf,
+  toCanonicalYaml
+} from "./chunk-S2A7YC3Q.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/workspace/dist/git.js
+import { execFile } from "node:child_process";
+var GitError = class extends Error {
+  args;
+  exitCode;
+  stderr;
+  constructor(message, args, exitCode, stderr) {
+    super(message);
+    this.args = args;
+    this.exitCode = exitCode;
+    this.stderr = stderr;
+    this.name = "GitError";
+  }
+};
+function createGit(opts = {}) {
+  const env = {
+    ...opts.env ?? process.env,
+    GIT_TERMINAL_PROMPT: "0",
+    GIT_PAGER: "cat",
+    LC_ALL: "C"
+  };
+  return (args, cwd) => new Promise((resolve, reject) => {
+    execFile("git", args, {
+      cwd,
+      env,
+      timeout: opts.timeoutMs ?? 10 * 6e4,
+      maxBuffer: 64 * 1024 * 1024,
+      windowsHide: true,
+      encoding: "utf8"
+    }, (err, stdout, stderr) => {
+      if (err) {
+        const code = typeof err.code === "number" ? err.code : null;
+        const detail = (stderr || err.message).trim().split(/\r?\n/).slice(-3).join(" ");
+        reject(new GitError(`git ${args[0] ?? ""} failed: ${detail}`, args, code, stderr));
+        return;
+      }
+      resolve({ stdout, stderr });
+    });
+  });
+}
+
+// packages/workspace/dist/changes.js
+var STATUS = {
+  A: "added",
+  M: "modified",
+  D: "deleted",
+  R: "renamed",
+  C: "copied",
+  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 parts = r.stdout.split("\0");
+  const out = [];
+  for (let i = 0; i < parts.length; ) {
+    const code = parts[i++] ?? "";
+    if (!code)
+      continue;
+    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 });
+    } else {
+      const path = parts[i++] ?? "";
+      if (path)
+        out.push({ status: status ?? "modified", path });
+    }
+  }
+  return out.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+}
+var sameCommit = (a, b) => a.startsWith(b) || b.startsWith(a);
+async function changesSince(dir, commits, to, git) {
+  const changes = {};
+  const missing = [];
+  for (const c of [...new Set(commits)].filter((x) => !sameCommit(x, to)).sort()) {
+    try {
+      changes[c] = await changedFiles(dir, c, to, git);
+    } catch {
+      missing.push(c);
+    }
+  }
+  return { changes, missing };
+}
+
+// packages/workspace/dist/layout.js
+import { readFile, writeFile } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+var WORKSPACE_DIR = "workspace";
+var IGNORED = ["/workspace/", "/.index/", "/.runs/"];
+function id(what, value) {
+  if (!RecordId.safeParse(value).success)
+    throw new Error(`${what} "${value}" must be a lowercase slug`);
+  return value;
+}
+function baseClonePath(root, repo) {
+  return join(root, WORKSPACE_DIR, id("repo id", repo));
+}
+var branchSlug = (branch) => branch.replace(/[^A-Za-z0-9.-]+/g, "-");
+function branchCheckoutPath(root, repo, branch) {
+  return join(root, WORKSPACE_DIR, ".branches", id("repo id", repo), branchSlug(branch));
+}
+function changeWorktreesDir(root, change) {
+  return join(root, WORKSPACE_DIR, ".worktrees", id("change id", change));
+}
+function worktreePath(root, change, repo) {
+  return join(changeWorktreesDir(root, change), id("repo id", repo));
+}
+function changeDir(root, change) {
+  return join(changesDirOf(root), id("change id", change));
+}
+function changeReposPath(root, change) {
+  return join(changeDir(root, change), "repos.yaml");
+}
+function vscodeWorkspacePath(root, change) {
+  return join(root, WORKSPACE_DIR, `${id("change id", change)}.code-workspace`);
+}
+function intellijProjectPath(root, change) {
+  return join(root, WORKSPACE_DIR, ".intellij", id("change id", change));
+}
+function toRepoRelative(root, path) {
+  return relative(root, path).split(sep).join("/");
+}
+async function ensureGitignore(root) {
+  const path = join(root, ".gitignore");
+  let text = "";
+  try {
+    text = await readFile(path, "utf8");
+  } catch {
+  }
+  const norm = (l) => l.trim().replace(/^\//, "").replace(/\/$/, "");
+  const have = new Set(text.split(/\r?\n/).map(norm));
+  const missing = IGNORED.filter((p) => !have.has(norm(p)));
+  if (missing.length > 0) {
+    const prefix = text === "" || text.endsWith("\n") ? text : text + "\n";
+    await writeFile(path, `${prefix}${prefix ? "\n" : ""}# Atticus local state
+${missing.join("\n")}
+`, "utf8");
+  }
+  return missing;
+}
+
+// packages/workspace/dist/files.js
+var import_yaml = __toESM(require_dist(), 1);
+import { mkdir, readdir, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname, join as join2 } from "node:path";
+var WorkspaceFileError = class extends Error {
+  path;
+  constructor(message, path) {
+    super(message);
+    this.path = path;
+    this.name = "WorkspaceFileError";
+  }
+};
+function describe(issues) {
+  return issues.map((i) => `${i.path.map(String).join(".") || "(file)"}: ${i.message}`).join("; ");
+}
+async function readYaml(path) {
+  const text = await readFile2(path, "utf8");
+  try {
+    return (0, import_yaml.parse)(text);
+  } catch (err) {
+    throw new WorkspaceFileError(`${path}: invalid YAML: ${err.message}`, path);
+  }
+}
+async function loadManifest(path) {
+  const r = RepoManifest.safeParse(await readYaml(path));
+  if (!r.success)
+    throw new WorkspaceFileError(`${path}: ${describe(r.error.issues)}`, path);
+  return r.data;
+}
+async function loadRepos(root) {
+  const profiles = join2(orgPackDirOf(root), "profiles");
+  let names;
+  try {
+    names = (await readdir(profiles, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name).sort();
+  } catch {
+    return [];
+  }
+  const out = [];
+  const where = /* @__PURE__ */ new Map();
+  for (const name of names) {
+    const path = join2(profiles, name, "repos.manifest.yaml");
+    try {
+      await readFile2(path);
+    } catch {
+      continue;
+    }
+    const m = await loadManifest(path);
+    for (const repo of m.repos) {
+      const other = where.get(repo.id);
+      if (other)
+        throw new WorkspaceFileError(`repo id ${repo.id} is in both ${other} and ${m.platform}`, path);
+      where.set(repo.id, m.platform);
+      out.push({ ...repo, platform: m.platform });
+    }
+  }
+  return out;
+}
+var CHANGE_REPOS_KEYS = ["schemaVersion", "change", "id"];
+async function readChangeRepos(root, change) {
+  const path = changeReposPath(root, change);
+  try {
+    await readFile2(path);
+  } catch {
+    return void 0;
+  }
+  const r = ChangeRepos.safeParse(await readYaml(path));
+  if (!r.success)
+    throw new WorkspaceFileError(`${path}: ${describe(r.error.issues)}`, path);
+  if (r.data.change !== change)
+    throw new WorkspaceFileError(`${path}: says change ${r.data.change}, expected ${change}`, path);
+  return r.data;
+}
+async function writeChangeRepos(root, value) {
+  const data = ChangeRepos.parse(value);
+  const path = changeReposPath(root, data.change);
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile2(path, toCanonicalYaml(data, CHANGE_REPOS_KEYS), "utf8");
+  return path;
+}
+
+// packages/workspace/dist/editors.js
+import { existsSync } from "node:fs";
+import { mkdir as mkdir2, 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) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function vscodeWorkspace(root, repos) {
+  const from = join3(root, WORKSPACE_DIR);
+  const folders = [
+    { name: "metarepo", path: posix(relative2(from, root)) }
+  ];
+  for (const r of repos.repos)
+    folders.push({ name: r.id, path: posix(relative2(from, join3(root, r.worktree))) });
+  const runs = join3(runsDirOf(root), repos.change);
+  if (existsSync(runs))
+    folders.push({ name: "context pack", path: posix(relative2(from, runs)) });
+  return {
+    folders,
+    settings: {
+      // The metarepo folder must not show the clones a second time.
+      "files.exclude": { workspace: true, ".index": true },
+      "search.exclude": { workspace: true, ".index": true, ".runs": true },
+      "git.autoRepositoryDetection": "subFolders"
+    }
+  };
+}
+function intellijProject(root, repos) {
+  const projectDir = intellijProjectPath(root, repos.change);
+  const ideaDir = join3(projectDir, ".idea");
+  const rel = (p) => "$MODULE_DIR$/" + posix(relative2(ideaDir, p));
+  const projectRel = (p) => "$PROJECT_DIR$/" + posix(relative2(projectDir, p));
+  const modules = [
+    { name: "metarepo", dir: root, excludes: [join3(root, WORKSPACE_DIR), join3(root, ".index")] },
+    ...repos.repos.map((r) => ({ name: r.id, dir: join3(root, r.worktree), excludes: [] }))
+  ];
+  const runs = join3(runsDirOf(root), repos.change);
+  if (existsSync(runs))
+    modules.push({ name: "context-pack", dir: runs, excludes: [] });
+  const files = {};
+  files[".name"] = `${repos.change}
+`;
+  files["modules.xml"] = [
+    `<?xml version="1.0" encoding="UTF-8"?>`,
+    `<project version="4">`,
+    `  <component name="ProjectModuleManager">`,
+    `    <modules>`,
+    ...modules.map((m) => `      <module fileurl="file://$PROJECT_DIR$/.idea/${xmlEscape(m.name)}.iml" filepath="$PROJECT_DIR$/.idea/${xmlEscape(m.name)}.iml" />`),
+    `    </modules>`,
+    `  </component>`,
+    `</project>`,
+    ``
+  ].join("\n");
+  for (const m of modules) {
+    files[`${m.name}.iml`] = [
+      `<?xml version="1.0" encoding="UTF-8"?>`,
+      `<module type="GENERAL_MODULE" version="4">`,
+      `  <component name="NewModuleRootManager" inherit-compiler-output="true">`,
+      `    <exclude-output />`,
+      `    <content url="file://${xmlEscape(rel(m.dir))}">`,
+      ...m.excludes.map((e) => `      <excludeFolder url="file://${xmlEscape(rel(e))}" />`),
+      `    </content>`,
+      `    <orderEntry type="sourceFolder" forTests="false" />`,
+      `  </component>`,
+      `</module>`,
+      ``
+    ].join("\n");
+  }
+  files["vcs.xml"] = [
+    `<?xml version="1.0" encoding="UTF-8"?>`,
+    `<project version="4">`,
+    `  <component name="VcsDirectoryMappings">`,
+    // The metarepo and each worktree are separate Git repositories.
+    ...modules.filter((m) => m.name !== "context-pack").map((m) => `    <mapping directory="${xmlEscape(projectRel(m.dir))}" vcs="Git" />`),
+    `  </component>`,
+    `</project>`,
+    ``
+  ].join("\n");
+  return files;
+}
+async function writeEditorWorkspaces(root, repos) {
+  const vscode = vscodeWorkspacePath(root, repos.change);
+  await mkdir2(join3(root, WORKSPACE_DIR), { recursive: true });
+  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))) {
+    await writeFile3(join3(ideaDir, name), text, "utf8");
+  }
+  return { vscode, intellij };
+}
+async function removeEditorWorkspaces(root, change) {
+  await rm(vscodeWorkspacePath(root, change), { force: true });
+  await rm(intellijProjectPath(root, change), { recursive: true, force: true });
+}
+
+// packages/workspace/dist/state.js
+async function checkoutState(dir, git = createGit()) {
+  const commit = (await git(["rev-parse", "HEAD"], dir)).stdout.trim();
+  const status = (await git(["status", "--porcelain", "--untracked-files=normal"], dir)).stdout.trim();
+  return { commit, dirty: status !== "" };
+}
+
+// packages/workspace/dist/manager.js
+import { existsSync as existsSync2 } from "node:fs";
+import { mkdir as mkdir3, readdir as readdir2, rm as rm2 } from "node:fs/promises";
+import { basename, dirname as dirname2, join as join4 } from "node:path";
+function isInPlace(url) {
+  return url === "." || url.startsWith("./");
+}
+async function remoteDefaultBranch(dir, git = createGit()) {
+  if (!existsSync2(dir))
+    return void 0;
+  try {
+    const r = (await git(["symbolic-ref", "--short", "refs/remotes/origin/HEAD"], dir)).stdout;
+    return r.trim().replace(/^origin\//, "") || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function createWorkspace(root, git = createGit()) {
+  const g = (args, cwd = root) => git(args, cwd);
+  const head = async (cwd) => (await g(["rev-parse", "HEAD"], cwd)).stdout.trim();
+  const dirty = async (cwd) => (await g(["status", "--porcelain", "--untracked-files=normal"], cwd)).stdout.trim() !== "";
+  const refExists = async (cwd, ref) => {
+    try {
+      await g(["rev-parse", "--verify", "--quiet", ref], cwd);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const remoteDefault = async (cwd) => {
+    try {
+      await g(["remote", "set-head", "origin", "--auto"], cwd);
+    } catch {
+    }
+    const b = await remoteDefaultBranch(cwd, git);
+    return b ? { remoteDefault: b } : {};
+  };
+  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", "--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))
+      return {
+        id: repo.id,
+        action: "skipped",
+        reason: `in place at ${repo.url}, nothing to clone`
+      };
+    const dest = baseClonePath(root, repo.id);
+    const branch = repo.defaultBranch;
+    try {
+      if (!existsSync2(dest)) {
+        await mkdir3(dirname2(dest), { recursive: true });
+        const from = local && yourClone(local, repo);
+        if (from)
+          return await copyFrom(repo, from, dest);
+        const args = ["clone", "--no-tags", "--branch", branch, "--filter=blob:none"];
+        if (repo.sparse.length > 0)
+          args.push("--sparse");
+        args.push("--", repo.url, dest);
+        await g(args);
+        if (repo.sparse.length > 0)
+          await g(["sparse-checkout", "set", "--", ...repo.sparse], dest);
+        return {
+          id: repo.id,
+          action: "cloned",
+          sha: await head(dest),
+          ...await remoteDefault(dest)
+        };
+      }
+      if (await dirty(dest)) {
+        return {
+          id: repo.id,
+          action: "skipped",
+          sha: await head(dest),
+          reason: "the base clone has local changes; base clones are read-only"
+        };
+      }
+      await g(["fetch", "--no-tags", "origin", `+refs/heads/${branch}:refs/remotes/origin/${branch}`], dest);
+      await g(["checkout", "--quiet", "-B", branch, `refs/remotes/origin/${branch}`], dest);
+      if (repo.sparse.length > 0)
+        await g(["sparse-checkout", "set", "--", ...repo.sparse], dest);
+      return {
+        id: repo.id,
+        action: "updated",
+        sha: await head(dest),
+        ...await remoteDefault(dest)
+      };
+    } catch (err) {
+      return { id: repo.id, action: "failed", reason: err.message };
+    }
+  }
+  async function worktreeFor(change, repo) {
+    const base = baseClonePath(root, repo.id);
+    if (!existsSync2(base))
+      throw new Error(`no base clone for ${repo.id}; run atticus workspace sync first`);
+    const branch = changeBranch(change);
+    const path = worktreePath(root, change, repo.id);
+    const baseRef = `refs/remotes/origin/${repo.defaultBranch}`;
+    const baseSha = (await g(["rev-parse", baseRef], base)).stdout.trim();
+    if (!existsSync2(path)) {
+      await mkdir3(dirname2(path), { recursive: true });
+      try {
+        await g(["fetch", "--no-tags", "origin", `+refs/heads/${branch}:refs/remotes/origin/${branch}`], base);
+      } catch {
+      }
+      if (await refExists(base, `refs/heads/${branch}`)) {
+        await g(["worktree", "add", "--", path, branch], base);
+      } else if (await refExists(base, `refs/remotes/origin/${branch}`)) {
+        await g(["worktree", "add", "--track", "-b", branch, "--", path, `refs/remotes/origin/${branch}`], base);
+      } else {
+        await g(["worktree", "add", "--no-track", "-b", branch, "--", path, baseRef], base);
+      }
+    }
+    return {
+      id: repo.id,
+      branch,
+      base: repo.defaultBranch,
+      baseSha,
+      worktree: toRepoRelative(root, path),
+      build: { status: "not-run" }
+    };
+  }
+  return {
+    root,
+    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, 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) };
+    },
+    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 prior = byId.get(repo.id);
+        byId.set(repo.id, prior ? { ...fresh, ...prior, worktree: fresh.worktree } : fresh);
+      }
+      const value = {
+        schemaVersion: WORKSPACE_SCHEMA_VERSION,
+        change,
+        repos: [...byId.values()].sort((a, b) => a.id.localeCompare(b.id))
+      };
+      await writeChangeRepos(root, value);
+      await writeEditorWorkspaces(root, value);
+      return value;
+    },
+    async prune(change, opts = {}) {
+      const repos = await readChangeRepos(root, change);
+      const removed = [];
+      const kept = [];
+      if (!repos)
+        return { removed, kept };
+      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" });
+          continue;
+        }
+        const path = worktreePath(root, change, r.id);
+        if (!existsSync2(path)) {
+          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" });
+            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) });
+        }
+      }
+      for (const r of repos.repos) {
+        if (existsSync2(baseClonePath(root, r.id)))
+          await g(["worktree", "prune"], baseClonePath(root, r.id)).catch(() => void 0);
+      }
+      if (kept.length === 0) {
+        await removeEditorWorkspaces(root, change);
+        await rm2(changeWorktreesDir(root, change), { recursive: true, force: true });
+      }
+      return { removed, kept };
+    }
+  };
+}
+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 readdir2(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:${basename(d)}`))
+        found.set(`name:${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:${repo.id}`);
+
+// packages/workspace/dist/identity.js
+import { userInfo } from "node:os";
+function toHandle(s) {
+  return s.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/-{2,}/g, "-").replace(/^[^a-z0-9]+/, "").replace(/[-._]+$/, "").slice(0, 100);
+}
+async function config(git, root, key) {
+  try {
+    const v = (await git(["config", "--get", key], root)).stdout.trim();
+    return v || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function osUser() {
+  try {
+    return userInfo().username || void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function gitUser(root, o = {}) {
+  const git = o.git ?? createGit({ timeoutMs: 1e4, ...o.env ? { env: o.env } : {} });
+  const [name, email] = await Promise.all([
+    config(git, root, "user.name"),
+    config(git, root, "user.email")
+  ]);
+  const fromEmail = email ? toHandle(email.split("@")[0]) : "";
+  const fromName = name ? toHandle(name) : "";
+  const handle = fromEmail || fromName;
+  if (handle)
+    return {
+      handle,
+      ...name ? { name } : {},
+      ...email ? { email } : {},
+      source: "git"
+    };
+  const os = toHandle((o.osUser ?? osUser)() ?? "") || "someone";
+  return {
+    handle: os,
+    source: "os",
+    warning: `Git has no user here, so Atticus records you as ${os} (your OS user name). Set yours once: git config --global user.name "Your Name" and git config --global user.email you@example.com.`
+  };
+}
+
+export {
+  GitError,
+  createGit,
+  changedFiles,
+  changesSince,
+  WORKSPACE_DIR,
+  IGNORED,
+  baseClonePath,
+  branchSlug,
+  branchCheckoutPath,
+  changeWorktreesDir,
+  worktreePath,
+  changeDir,
+  changeReposPath,
+  vscodeWorkspacePath,
+  intellijProjectPath,
+  toRepoRelative,
+  ensureGitignore,
+  WorkspaceFileError,
+  loadManifest,
+  loadRepos,
+  readChangeRepos,
+  writeChangeRepos,
+  vscodeWorkspace,
+  intellijProject,
+  writeEditorWorkspaces,
+  removeEditorWorkspaces,
+  checkoutState,
+  isInPlace,
+  remoteDefaultBranch,
+  createWorkspace,
+  toHandle,
+  gitUser
+};