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

package/dist/chunk-SQV37XO2.js

@@ -0,0 +1,273 @@
+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 {
+  rulesLackingAll
+} from "./chunk-WXFLMQSR.js";
+import {
+  loadReadPlan
+} from "./chunk-TYQBFTBR.js";
+import {
+  carryOf,
+  checkoutOf,
+  excludesOf
+} from "./chunk-2F4CYZKJ.js";
+import {
+  isMetarepo,
+  notMetarepo
+} from "./chunk-3G4YI4ZU.js";
+import {
+  dirSource,
+  rereadPlan,
+  sameCommit
+} from "./chunk-CXJ6FUKN.js";
+import {
+  loadRepos
+} from "./chunk-PKBHS4AA.js";
+import {
+  citedFiles,
+  factsDirOf,
+  factsFileOf,
+  factsRelOf,
+  headFromFiles,
+  parseFacts
+} from "./chunk-Q2TECDIT.js";
+
+// packages/cli/dist/estate-fresh.js
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+var FRESH_STATES = [
+  /** Facts cite files that changed, or source files changed: read again. */
+  "stale",
+  /** The clone doesn't have the commit the facts were read at: they can't be compared. */
+  "unknown-commit",
+  /** The clone moved, but nothing the facts cite changed and no source file did: carry them. */
+  "moved",
+  /**
+   * ADR 0167: the facts are of the clone's commit, but the read lacked rule sets added since
+   * (or recorded none, before 2.0.0-beta.12): a top-up reads the files those sets apply to.
+   */
+  "rules-changed",
+  /** No clone to compare with. */
+  "no-checkout",
+  /** The facts are of the commit the clone is at. */
+  "fresh",
+  /** No facts yet: the repo isn't read. */
+  "not-read"
+];
+var RANK = Object.fromEntries(FRESH_STATES.map((s, i) => [s, i]));
+function freshOrder(a, b) {
+  return RANK[a.state] - RANK[b.state] || b.reread - a.reread || b.citedChanged - a.citedChanged || b.toRead - a.toRead || b.changed - a.changed || (a.repo < b.repo ? -1 : a.repo > b.repo ? 1 : 0);
+}
+async function pool(xs, n, f) {
+  const out = new Array(xs.length);
+  let next = 0;
+  const worker = async () => {
+    for (let i = next++; i < xs.length; i = next++)
+      out[i] = await f(xs[i]);
+  };
+  await Promise.all(Array.from({ length: Math.min(n, xs.length) }, worker));
+  return out;
+}
+var firstLine = (e) => String(e?.message ?? e).split("\n")[0];
+async function freshOf(root, repo, o, problems) {
+  const factsFile = `${factsRelOf(root)}/${repo}.jsonl`;
+  const base = {
+    repo,
+    factsFile,
+    facts: 0,
+    factsCommits: [],
+    current: 0,
+    carried: 0,
+    reread: 0,
+    citedChanged: 0,
+    changed: 0,
+    toRead: 0,
+    unknown: []
+  };
+  const read = { command: `atticus map ${repo}`, slash: `/atticus-map ${repo}` };
+  const text = await readFile(join(factsDirOf(root), `${repo}.jsonl`), "utf8").catch(() => void 0);
+  if (text === void 0 || !text.trim())
+    return { ...base, state: "not-read", ...read };
+  const parsed = parseFacts(text);
+  if (!parsed.ok) {
+    problems.push({
+      file: factsFile,
+      message: `doesn't read as facts: ${parsed.issues[0]?.message ?? "invalid"}`
+    });
+    return { ...base, state: "not-read", ...read };
+  }
+  const facts = parsed.facts;
+  const commits = [...new Set(facts.map((f) => f.commit))].sort();
+  const counted = { ...base, facts: facts.length, factsCommits: commits };
+  const dir = await checkoutOf(root, repo).catch(() => void 0);
+  const head = dir ? await headFromFiles(dir) : void 0;
+  if (!dir || !head)
+    return { ...counted, state: "no-checkout", command: "atticus workspace sync" };
+  const at = { ...counted, head };
+  if (facts.every((f) => sameCommit(f.commit, head))) {
+    const lacking = await rulesLackingAll(root, repo, (await loadReadPlan(root, repo).catch(() => void 0))?.rules, { dir });
+    return lacking.length ? {
+      ...at,
+      state: "rules-changed",
+      current: facts.length,
+      rulesLacking: lacking,
+      command: `atticus map ${repo} --rules`,
+      slash: `/atticus-map ${repo} --rules`
+    } : { ...at, state: "fresh", current: facts.length };
+  }
+  let carry;
+  try {
+    carry = await carryOf(dir, facts, head, o.git);
+  } catch (e) {
+    problems.push({
+      file: factsFile,
+      message: `git couldn't compare the commits: ${firstLine(e)}`
+    });
+    return { ...at, state: "unknown-commit", unknown: commits, reread: facts.length, ...read };
+  }
+  const plan = rereadPlan({
+    facts,
+    commit: head,
+    carry: carry.carry,
+    source: dirSource(dir),
+    exclude: await excludesOf(root, repo)
+  });
+  const unknown = [.../* @__PURE__ */ new Set([...plan.unknown, ...carry.missing])].sort();
+  const lost = facts.filter((f) => unknown.some((c) => sameCommit(c, f.commit))).length;
+  const changedPaths = /* @__PURE__ */ new Set();
+  for (const cs of Object.values(carry.carry))
+    for (const c of cs) {
+      changedPaths.add(c.path);
+      if (c.from)
+        changedPaths.add(c.from);
+    }
+  const cited = /* @__PURE__ */ new Set();
+  for (const f of facts) {
+    if (sameCommit(f.commit, head) || unknown.some((c) => sameCommit(c, f.commit)))
+      continue;
+    for (const p of citedFiles(f))
+      if (changedPaths.has(p))
+        cited.add(p);
+  }
+  const changed = new Set(Object.values(carry.carry).flatMap((cs) => cs.map((c) => c.path))).size;
+  const out = {
+    ...at,
+    current: plan.current,
+    carried: plan.carried,
+    reread: plan.reread.length + lost,
+    citedChanged: cited.size,
+    changed,
+    toRead: plan.files.length,
+    unknown
+  };
+  if (unknown.length)
+    return { ...out, state: "unknown-commit", command: "atticus workspace sync" };
+  if (!out.reread && !out.toRead)
+    return { ...out, state: "moved", command: `atticus verify ${repo} --write` };
+  return { ...out, state: "stale", ...read };
+}
+async function estateFreshness(root, o = {}) {
+  const problems = [];
+  const ids = [];
+  try {
+    for (const r of await loadRepos(root))
+      if (!r.archived)
+        ids.push(r.id);
+  } catch (e) {
+    problems.push({ file: "org-pack/profiles", message: firstLine(e) });
+  }
+  for (const n of (await readdir(factsDirOf(root)).catch(() => [])).sort()) {
+    const of = factsFileOf(n);
+    if (of?.facts && !ids.includes(of.repo))
+      ids.push(of.repo);
+  }
+  const want = o.repos ? ids.filter((id) => o.repos.includes(id)) : ids;
+  const repos = await pool(want, 4, (id) => freshOf(root, id, o, problems));
+  return { factsDir: factsRelOf(root), repos: repos.sort(freshOrder), problems };
+}
+var short = (c) => c.slice(0, 12);
+var plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+var factsCommitWords = (r) => r.factsCommits.length === 0 ? "-" : r.factsCommits.length === 1 ? short(r.factsCommits[0]) : `${short(r.factsCommits[0])} +${r.factsCommits.length - 1}`;
+function freshWhy(r) {
+  switch (r.state) {
+    case "stale":
+      return `${plural(r.reread, "fact")} to read again (${plural(r.citedChanged, "file")} they cite changed), ${r.carried} carried as they are; ${plural(r.toRead, "source file")} to read.`;
+    case "unknown-commit":
+      return `The clone doesn't have ${r.unknown.map(short).join(", ")}, the commit the facts were read at: sync it, or read the repo again whole.`;
+    case "moved":
+      return `The clone moved, but nothing the facts cite changed and no source file did: verify carries all ${plural(r.carried + r.current, "fact")}.`;
+    case "rules-changed":
+      return `Its facts are of the clone's commit, but it was read before these reading rules: ${(r.rulesLacking ?? []).join(", ")}. A top-up reads only the files they apply to.`;
+    case "no-checkout":
+      return "No clone to compare the facts with.";
+    case "fresh":
+      return "The facts are of the commit the clone is at.";
+    default:
+      return "Not read yet.";
+  }
+}
+async function estateFresh(root, o, io) {
+  if (!isMetarepo(root)) {
+    io.err(notMetarepo(root));
+    return 2;
+  }
+  const v = await estateFreshness(root, o.git ? { git: o.git } : {});
+  if (o.json) {
+    io.out(JSON.stringify(v, null, 2));
+    return 0;
+  }
+  for (const p of v.problems)
+    io.err(`Couldn't read ${p.file}: ${p.message}`);
+  const read = v.repos.filter((r) => r.state !== "not-read");
+  if (!read.length) {
+    io.out(v.repos.length ? `No repo is read yet, so none can be stale: atticus next says which to read first.` : "No repo is listed yet: atticus next says how to start.");
+    return 0;
+  }
+  const stale = read.filter((r) => r.state !== "fresh");
+  const moved = stale.filter((r) => r.state !== "rules-changed");
+  const rules = stale.length - moved.length;
+  const facts = moved.reduce((n, r) => n + r.reread, 0);
+  if (moved.length || !rules)
+    io.out(moved.length ? `${plural(moved.length, "repo")} of ${read.length} read ${moved.length === 1 ? "has" : "have"} moved past ${moved.length === 1 ? "its" : "their"} facts' commit: ${plural(facts, "fact")} to read again. Most stale first:` : `All ${plural(read.length, "repo")} read are fresh: each one's facts are of the commit its clone is at.`);
+  if (rules)
+    io.out(`${plural(rules, "repo")} of ${read.length} read ${rules === 1 ? "was" : "were"} read before reading rules added since: atticus map --all --stale tops ${rules === 1 ? "it" : "them"} up, reading only the files the new rules apply to.`);
+  const shown = o.all ? read : stale;
+  if (shown.length) {
+    const rows = shown.map((r) => [
+      r.repo,
+      r.state,
+      factsCommitWords(r),
+      r.head ? short(r.head) : "-",
+      String(r.citedChanged),
+      String(r.reread),
+      r.command ?? ""
+    ]);
+    const head = ["repo", "state", "facts at", "clone at", "cited changed", "to read again", "run"];
+    const w = head.map((h, i) => Math.max(h.length, ...rows.map((x) => x[i].length)));
+    const line = (cells) => cells.map((c, i) => i === cells.length - 1 ? c : c.padEnd(w[i])).join("  ").trimEnd();
+    io.out(line(head));
+    for (const r of rows)
+      io.out(line(r));
+    for (const r of shown.filter((x) => x.state !== "fresh"))
+      io.out(`  ${r.repo}: ${freshWhy(r)}`);
+  }
+  const fresh = read.length - stale.length;
+  if (fresh && !o.all && stale.length)
+    io.out(`${plural(fresh, "repo")} fresh (--all lists them too).`);
+  const unread = v.repos.length - read.length;
+  if (unread)
+    io.out(`${plural(unread, "repo")} not read yet: atticus next says which to read first.`);
+  return 0;
+}
+
+export {
+  FRESH_STATES,
+  freshOrder,
+  estateFreshness,
+  factsCommitWords,
+  freshWhy,
+  estateFresh
+};

package/dist/{chunk-K65BJIMT.js → chunk-SU74NDMQ.js}

@@ -14,25 +14,27 @@ import {
   onboardFrameworkCheck,
   scanReview,
   scanSurvey
-} from "./chunk-GLUX4EEP.js";
-import "./chunk-FITWGOJ2.js";
+} from "./chunk-4EURQWQD.js";
+import "./chunk-OHNCWBKF.js";
 import {
   repoFor
-} from "./chunk-O3WI5KWW.js";
-import "./chunk-KEM4SDDP.js";
-import "./chunk-ZVM6AKKM.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-T6AIP7H5.js";
-import "./chunk-EFHQ3TWP.js";
-import "./chunk-GQ4N4WKF.js";
-import "./chunk-CNUKCS2T.js";
-import "./chunk-S2A7YC3Q.js";
-import "./chunk-D3PO4DOZ.js";
+} from "./chunk-LO6P2VYG.js";
+import "./chunk-O7FDLW7L.js";
+import "./chunk-PJSJPMJI.js";
+import "./chunk-ISUAAMGS.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 {
   matchedRepoType,

package/dist/chunk-SYV5LHML.js

@@ -0,0 +1,165 @@
+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 {
+  describeRun
+} from "./chunk-VTZMAJ3W.js";
+import {
+  RunLevel,
+  readyTasksOf,
+  runReadyTasks
+} from "./chunk-6MUGR4LS.js";
+import "./chunk-DOBQKHIF.js";
+import "./chunk-JENSEMXF.js";
+import "./chunk-O7FDLW7L.js";
+import "./chunk-HNM2YQT2.js";
+import "./chunk-PAQ2AS5E.js";
+import "./chunk-RUGXBPWI.js";
+import "./chunk-BTGPE6CR.js";
+import "./chunk-MUWDB4R4.js";
+import "./chunk-ZQ7SKESZ.js";
+import "./chunk-UGUP3ZM6.js";
+import "./chunk-R7NYHMUU.js";
+import "./chunk-IVBOQAGB.js";
+import "./chunk-ISUAAMGS.js";
+import "./chunk-BEVTIBRH.js";
+import "./chunk-UF4AZOZB.js";
+import "./chunk-YHCMZC2J.js";
+import "./chunk-VOGCSYOI.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 {
+  RUNTIME_MODES
+} from "./chunk-P32RUW3B.js";
+import "./chunk-QA4O2GGC.js";
+import "./chunk-Q2TECDIT.js";
+import "./chunk-TUULXQRW.js";
+import "./chunk-BQGDB6ZL.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/run-ready-commands.js
+async function deployOrderOf(root, change) {
+  try {
+    const { loadRelease, deploymentPlan } = await import("./chunk-WMTRHUI5.js");
+    const plan = await deploymentPlan(await loadRelease(root, change));
+    const out = [];
+    for (const s of [...plan.steps].sort((a, b) => a.n - b.n))
+      if (!out.includes(s.repo))
+        out.push(s.repo);
+    return out;
+  } catch {
+    return void 0;
+  }
+}
+function readyLines(change, p) {
+  if (!p.tasks.length)
+    return [`Every task of ${change} is done.`];
+  const repoOf = new Map(p.tasks.map((t) => [t.id, t.repo]));
+  const out = p.ready.length ? [
+    `Ready to run, in cross-repo order: ${p.ready.map((id) => `${id} (${repoOf.get(id)})`).join(", ")}.`
+  ] : [`No task of ${change} is ready to run.`];
+  for (const t of p.tasks.filter((x) => !x.ready))
+    out.push(`  Not ready: task ${t.id}: ${t.why}.`);
+  return out;
+}
+async function taskRunReady(root, changeId, o, io, deps = {}) {
+  if (!changeId) {
+    io.err("Usage: atticus task run-ready <change> [--level draft|pr] [--mode hand-off|model|headless-claude-code] [--approve] [--dry-run]");
+    return 2;
+  }
+  if (!o.by) {
+    io.err("Say who is running the tasks: set your Git user (git config user.name), or pass --by <you>.");
+    return 2;
+  }
+  if (o.level !== void 0 && !RunLevel.safeParse(o.level).success) {
+    io.err(`Unknown level ${o.level}. Use one of: plan, draft, pr.`);
+    return 2;
+  }
+  const env = deps.env ?? process.env;
+  const mode = o.mode ?? env.ATTICUS_RUNTIME;
+  if (mode !== void 0 && (!RUNTIME_MODES.includes(mode) || mode === "mock")) {
+    io.err(`Unknown mode ${mode}. Use one of: hand-off, model, headless-claude-code, replay.`);
+    return 2;
+  }
+  const repoOrder = deps.repoOrder ?? await deployOrderOf(root, changeId);
+  let plan;
+  try {
+    plan = await readyTasksOf(root, changeId, repoOrder ? { repoOrder } : {});
+  } catch (e) {
+    io.err(e.message);
+    return 1;
+  }
+  const level = o.level;
+  const dry = o.dryRun === true || level === "pr" && !o.approve;
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  let r;
+  try {
+    r = await runReadyTasks(root, changeId, {
+      by: o.by,
+      ...level ? { level } : {},
+      ...mode ? { mode } : {},
+      ...env.ATTICUS_REPLAY_DIR ? { replayDir: env.ATTICUS_REPLAY_DIR } : {},
+      ...repoOrder ? { repoOrder } : {},
+      ...dry ? { dryRun: true } : {},
+      ...o.approve ? {
+        approval: {
+          by: o.by,
+          at: now().toISOString(),
+          ref: `the ready tasks of ${changeId}: push and PR each (Run all ready tasks)`
+        }
+      } : {},
+      ...deps.runtime ? { runtime: deps.runtime } : {},
+      ...deps.runtimeOptions ? { runtimeOptions: deps.runtimeOptions } : {},
+      ...deps.commands ? { commands: deps.commands } : {},
+      ...deps.git ? { git: deps.git } : {},
+      ...deps.gitHost ? { gitHost: deps.gitHost } : {},
+      now
+    });
+  } catch (e) {
+    io.err(e.message);
+    return 1;
+  }
+  if (o.json) {
+    io.out(JSON.stringify({ change: changeId, ...plan, ...r, ...dry ? { dryRun: true } : {} }, null, 2));
+    return r.stopped ? 1 : 0;
+  }
+  for (const l of readyLines(changeId, plan))
+    io.out(l);
+  if (dry) {
+    for (const p of r.previews ?? [])
+      io.out("refused" in p ? `Task ${p.task}: ${p.refused}` : `Task ${p.task} on ${p.repo} at the ${p.level} level, on ${p.branch}${p.level === "pr" ? p.gitHost ? ", then its PR into the change branch." : "; no Git host is connected, so you push it and open the PR." : "."}`);
+    io.out(level === "pr" && !o.approve && !o.dryRun ? "Nothing was done: run it again with --approve to let each task's branch be pushed and its PR opened (the person's yes; an assistant never approves a push)." : "Nothing was done: this was a dry run.");
+    return 0;
+  }
+  for (const x of r.ran) {
+    if ("record" in x)
+      describeRun(root, x.record, io);
+    else
+      io.out(`Task ${x.task} wasn't run: ${x.refused}`);
+  }
+  if (r.stopped) {
+    const left = r.planned.slice(r.planned.indexOf(r.stopped.task) + 1);
+    io.out(`Stopped at task ${r.stopped.task}, which needs a person${left.length ? `; not run yet: ${left.join(", ")}` : ""}. Run atticus task run-ready ${changeId} again once it is picked up.`);
+    return 1;
+  }
+  if (r.ran.length)
+    io.out(`Ran ${r.ran.length} ${r.ran.length === 1 ? "task" : "tasks"}. A person reviews and merges each PR on the Git host; nothing was merged.`);
+  return 0;
+}
+export {
+  deployOrderOf,
+  readyLines,
+  taskRunReady
+};

package/dist/chunk-T4YPZIQN.js

@@ -0,0 +1,36 @@
+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 {
+  citesCli,
+  fileInRepo,
+  uiCiteRoutes
+} from "./chunk-QFWA2DPH.js";
+import "./chunk-C3RY6KU6.js";
+import "./chunk-GUX3PTYM.js";
+import "./chunk-ISUAAMGS.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 {
+  citesCli,
+  fileInRepo,
+  uiCiteRoutes
+};