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

package/dist/{chunk-MC3H7736.js → chunk-TWQRPM76.js}

@@ -10,7 +10,7 @@ import {
   globToRegExp,
   memoryRepo,
   scanRepo
-} from "./chunk-GQ4N4WKF.js";
+} from "./chunk-7AB6OWTV.js";
 import {
   Dialect,
   FrameworkModel,
@@ -26,7 +26,7 @@ import {
   renderExpr,
   renderTemplate,
   require_dist
-} from "./chunk-S2A7YC3Q.js";
+} from "./chunk-PAINMSID.js";
 import {
   __commonJS,
   __require,
@@ -18702,6 +18702,8 @@ function clientOf(type, method, names, source) {
   };
 }
 function addConstant(c, owner, name2, value2, source) {
+  if (name2 === "serialVersionUID")
+    return;
   c.constants[`${owner}.${name2}`] = { value: value2, source };
   if (/service/i.test(owner))
     c.serviceIds.push(`${owner}.${name2}`);
@@ -18752,7 +18754,7 @@ function assemble(c, o) {
   const model = FrameworkModel.parse({
     schemaVersion: 1,
     name: o.name,
-    packages: o.packages ?? [commonPrefix([...c.packages])].filter(Boolean),
+    packages: o.packages ?? packagesOf(c),
     artifacts: [...new Set(c.artifacts)],
     annotations,
     clients: c.clients,
@@ -18765,7 +18767,7 @@ async function learnFramework(repo, o) {
   const src = (path) => ({ kind: "code", ref: `${repo.name}:${path}` });
   const c = collected();
   for await (const path of repo.listFiles(["**/*.java", "**/pom.xml"])) {
-    if (/(^|\/)src\/test\//.test(path))
+    if (/(^|\/)src\/test\//.test(path) || isBuildOutput(path))
       continue;
     const text2 = await repo.readText(path);
     if (path.endsWith("pom.xml")) {
@@ -18878,6 +18880,25 @@ function learnFrameworkFromJar(jar, o) {
   }
   return assemble(c, o);
 }
+function isBuildOutput(path) {
+  const m = /(^|\/)(target|build)\//.exec(path);
+  return !!m && !path.slice(0, m.index).split("/").includes("src");
+}
+function packagesOf(c) {
+  const names = [...c.packages].sort();
+  if (names.length === 0)
+    throw new Error("no Java source with a package declaration was found (tests, target/ and build/ are left out). Point --from at the framework's own source, its JAR or its .tgz, or name its package with --package <base package>.");
+  const p = commonPrefix(names);
+  if (p)
+    return [p];
+  const count = /* @__PURE__ */ new Map();
+  for (const n of names) {
+    const r = n.split(".").slice(0, 2).join(".");
+    count.set(r, (count.get(r) ?? 0) + 1);
+  }
+  const roots = [...count.keys()].sort((a, b) => count.get(b) - count.get(a) || (a < b ? -1 : 1));
+  throw new Error(`its Java packages share no common package (${roots.slice(0, 6).join(", ")}${roots.length > 6 ? ", ..." : ""}), so the framework's can't be told. Name it with --package <base package>, e.g. --package ${roots[0]}.`);
+}
 function commonPrefix(names) {
   if (names.length === 0)
     return "";
@@ -19410,6 +19431,18 @@ async function houseDependencies(repo, groups) {
       for (const block of select(pom, "project/properties"))
         for (const p of block.children)
           props.set(p.name, p.text.trim());
+      const parentVersion = selectText(pom, "project/parent/version")?.text.trim();
+      const ownVersion = selectText(pom, "project/version")?.text.trim() || parentVersion;
+      const builtIn = {
+        "project.parent.version": parentVersion,
+        "parent.version": parentVersion,
+        "project.version": ownVersion,
+        version: ownVersion,
+        "pom.version": ownVersion
+      };
+      for (const [k, v] of Object.entries(builtIn))
+        if (v && !props.has(k))
+          props.set(k, v);
       const fill = (v) => v.replace(/\$\{([\w.-]+)\}/g, (s, k) => props.get(k) ?? s);
       for (const d of select(pom, "//dependency")) {
         const group = selectText(d, "groupId")?.text;

package/dist/chunk-TYD6I4CZ.js

@@ -0,0 +1,109 @@
+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 {
+  gatewayHostFix,
+  hostQuestionDrafts,
+  unknownHosts
+} from "./chunk-4SLBCEPD.js";
+import {
+  baseClonePath,
+  loadRepos
+} from "./chunk-XOL3GFW2.js";
+import {
+  fsRepo
+} from "./chunk-7AB6OWTV.js";
+import {
+  HOSTS_NONE,
+  HOSTS_OUTSIDE_INTERNAL,
+  HOSTS_OUTSIDE_VENDOR,
+  HOSTS_STEP,
+  hostMatches,
+  hostOfQuestion,
+  listQuestions,
+  raiseQuestions,
+  retireQuestion,
+  writeQuestion
+} from "./chunk-PAINMSID.js";
+
+// packages/cli/dist/host-questions.js
+import { stat } from "node:fs/promises";
+var HOSTS_RERUN = "atticus scan";
+var isDir = (p) => stat(p).then((s) => s.isDirectory(), () => false);
+async function askHosts(root, records, o) {
+  const repos = await loadRepos(root).catch(() => []);
+  const dirs = /* @__PURE__ */ new Map();
+  for (const r of repos) {
+    const dir = baseClonePath(root, r.id);
+    if (await isDir(dir))
+      dirs.set(r.id, dir);
+  }
+  const asks = await unknownHosts({
+    records,
+    repos,
+    handle: (id) => dirs.has(id) ? fsRepo(id, dirs.get(id), "0".repeat(40)) : void 0
+  });
+  const before = (await listQuestions(root, { step: HOSTS_STEP })).questions;
+  const asked = new Set(before.map((q) => hostOfQuestion(q)));
+  const raised = [];
+  const at = (o.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const reasked = [];
+  const OUTSIDE = /* @__PURE__ */ new Set([HOSTS_OUTSIDE_INTERNAL, HOSTS_OUTSIDE_VENDOR]);
+  const gateway = /* @__PURE__ */ new Map();
+  for (const { repo, draft, byPath } of hostQuestionDrafts(asks)) {
+    const host = hostOfQuestion(draft);
+    if (byPath?.length && host)
+      gateway.set(host, gatewayHostFix(host, byPath));
+    if (asked.has(hostOfQuestion(draft))) {
+      const old = before.find((q) => hostOfQuestion(q) === hostOfQuestion(draft));
+      if (!old || old.state !== "open" || old.options.some((x) => OUTSIDE.has(x.label)))
+        continue;
+      const add = draft.options.filter((x) => OUTSIDE.has(x.label));
+      const none = old.options.findIndex((x) => x.label === HOSTS_NONE);
+      const at2 = none < 0 ? old.options.length : none;
+      const next = {
+        ...old,
+        options: [...old.options.slice(0, at2), ...add, ...old.options.slice(at2)]
+      };
+      await writeQuestion(root, next);
+      reasked.push(next);
+      continue;
+    }
+    const r = await raiseQuestions(root, [draft], {
+      step: HOSTS_STEP,
+      repo,
+      command: o.command,
+      rerun: o.rerun ?? HOSTS_RERUN,
+      at
+    });
+    raised.push(...r.raised);
+  }
+  const hosts = new Set(asks.map((a) => a.host));
+  const open = before.map((q) => reasked.find((x) => x.id === q.id) ?? q).filter((q) => q.state === "open" && hosts.has(hostOfQuestion(q)));
+  const lines = [];
+  for (const q of before) {
+    const host = hostOfQuestion(q);
+    if (q.state !== "open" || !host || hosts.has(host))
+      continue;
+    const [name, port] = host.split(/:(?=\d+$)/);
+    const listing = repos.filter((r) => [...r.hosts, ...r.modules.flatMap((m) => m.hosts)].some((p) => hostMatches(p, name, port ? Number(port) : void 0))).map((r) => r.id);
+    if (!listing.length)
+      continue;
+    const why = `${listing.join(", ")} ${listing.length === 1 ? "lists" : "list"} ${host} under hosts in repos.manifest.yaml`;
+    await retireQuestion(root, q.id, { why, at });
+    lines.push(`Retired ${q.id} (${q.question}): ${why}.`);
+  }
+  for (const q of raised)
+    lines.push(gateway.has(hostOfQuestion(q)) ? `Calls to ${hostOfQuestion(q)} join no repo: no repo lists it under hosts. Asked ${q.id}: ${q.question} ${gateway.get(hostOfQuestion(q))}. If one repo alone answers on it, answer: atticus questions answer ${q.id} --option <n> (1 is ${q.options[0].label}).` : `Calls to ${hostOfQuestion(q)} join no repo: no repo lists it under hosts. Asked ${q.id}: ${q.question} Answer it: atticus questions answer ${q.id} --option <n> (1 is ${q.options[0].label}). If several repos answer on it (a shared gateway or platform host), don't pick one: list it under hosts on each of them in repos.manifest.yaml (with each one's basePath where the path tells them apart), and the question retires itself. If a system outside the estate answers on it, pick an outside system (another team's or a vendor's): it goes into the profile with the host as its alias.`);
+  for (const q of reasked)
+    lines.push(`Re-asked ${q.id} (${q.question}): it now offers an outside system, another team's or a vendor's, for a host no repo of the estate answers on.`);
+  for (const q of open)
+    lines.push(`Still open: ${q.question}${gateway.has(hostOfQuestion(q)) ? ` ${gateway.get(hostOfQuestion(q))}.` : ""} Answer it: atticus questions answer ${q.id} --option <n>, then ${o.rerun ?? HOSTS_RERUN}.`);
+  return { raised, reasked, open, lines };
+}
+
+export {
+  askHosts
+};

package/dist/chunk-U3NBK4EU.js

@@ -0,0 +1,420 @@
+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 {
+  modelsData,
+  reachPlanOf
+} from "./chunk-455SYIIE.js";
+import {
+  effectiveRules,
+  orgRulesLacking,
+  readingRulesText,
+  ruleIds,
+  ruleMatches
+} from "./chunk-GIFMBCTW.js";
+import {
+  loadReadPlan,
+  modelsModeOf,
+  recordNotReached,
+  saveReadPlan
+} from "./chunk-MD7KUEJ3.js";
+import {
+  FACT_RULES_HASH,
+  MODELS_RULE,
+  RULE_SETS,
+  factRulesFor,
+  factsReference,
+  ruleSetKinds,
+  rulesLacking,
+  rulesNow,
+  topUpWords
+} from "./chunk-3AQ2R5NL.js";
+import {
+  fileKinds,
+  kindsOf,
+  lineRangeOf,
+  planBatches,
+  readingRank,
+  sameCommit
+} from "./chunk-JYMIB5XY.js";
+import {
+  DATA_RULE,
+  neutralise,
+  wrapData
+} from "./chunk-QHJJMZLX.js";
+import {
+  citedFiles,
+  factsDirOf,
+  factsRelOf,
+  parseFacts
+} from "./chunk-PAINMSID.js";
+import {
+  writeFileAtomic
+} from "./chunk-ODMBPDDV.js";
+
+// packages/cli/dist/map-rules.js
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+var has = (a, b) => a.some((x) => b.includes(x));
+function applies(set, f) {
+  switch (set) {
+    case "field-types":
+    case "message-types":
+      return f.code ? f.rank === 2 || f.rank === 3 || f.cited.has("entry") || f.cited.has("call") || f.cited.has("field") : f.rank === 3 && f.kinds.includes("protocols");
+    case "mappings":
+      return f.kinds.includes("gateway");
+    case "terms":
+      return !f.code && has(f.kinds, ["config", "deploy", "gateway"]);
+    case "call-auth":
+      return f.code ? f.rank === 1 || f.rank === 3 || f.cited.has("call") : has(f.kinds, ["config", "gateway"]);
+  }
+}
+function topUpFiles(o) {
+  const whole = planBatches(o.source, {
+    room: Number.MAX_SAFE_INTEGER,
+    exclude: o.exclude,
+    ...o.conventions ? { conventions: o.conventions } : {},
+    ...o.reach?.reach.rooted && o.reach.reach.models ? { reach: { first: o.reach.first, leaveOut: o.reach.leaveOut } } : {}
+  });
+  const cites = /* @__PURE__ */ new Map();
+  for (const f of o.facts)
+    for (const p of citedFiles(f)) {
+      const k = cites.get(p) ?? /* @__PURE__ */ new Set();
+      k.add(f.kind);
+      cites.set(p, k);
+    }
+  const out = [];
+  for (const slice of whole.batches.flat()) {
+    const path = slice.path;
+    const rank = readingRank(path);
+    if (rank === 5)
+      continue;
+    const kinds = fileKinds(path);
+    const of = {
+      kinds,
+      rank,
+      code: kinds.includes("backend") || kinds.includes("frontend"),
+      cited: cites.get(path) ?? /* @__PURE__ */ new Set()
+    };
+    const sets = o.sets.filter((s) => has(kinds, ruleSetKinds(s)) && applies(s, of));
+    if (sets.length)
+      out.push({ path, tokens: slice.tokens, lines: slice.of, sets });
+  }
+  return out;
+}
+function ruleSetsOfFiles(files) {
+  const all = new Set(files.flatMap((f) => f.sets));
+  return [
+    ...RULE_SETS.filter((x) => all.has(x)),
+    ...[...all].filter((x) => x.startsWith("org:")).sort()
+  ];
+}
+function topUpSessions(files, room) {
+  const reads = [];
+  for (const f of files) {
+    if (f.tokens <= room || f.lines <= 1) {
+      reads.push({ path: f.path, file: f.path, tokens: f.tokens, sets: f.sets });
+      continue;
+    }
+    const per = Math.max(1, Math.floor(f.lines * room / f.tokens));
+    for (let from = 1; from <= f.lines; from += per) {
+      const to = Math.min(f.lines, from + per - 1);
+      reads.push({
+        path: `${f.path}#L${from}-L${to}`,
+        file: f.path,
+        tokens: Math.ceil(f.tokens * (to - from + 1) / f.lines),
+        sets: f.sets
+      });
+    }
+  }
+  const sessions = [];
+  for (const r of reads) {
+    const last = sessions.at(-1);
+    if (last && last.tokens + r.tokens <= room) {
+      last.reads.push(r);
+      last.tokens += r.tokens;
+    } else
+      sessions.push({ reads: [r], tokens: r.tokens });
+  }
+  return sessions.map((s) => ({
+    paths: s.reads.map((r) => r.path),
+    sets: ruleSetsOfFiles(s.reads),
+    files: new Set(s.reads.map((r) => r.file)).size,
+    tokens: s.tokens
+  }));
+}
+var stamp = () => (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+async function factsOf(root, repo) {
+  const text = await readFile(join(factsDirOf(root), `${repo}.jsonl`), "utf8").catch(() => "");
+  if (!text.trim())
+    return `${repo} isn't read yet: atticus map ${repo} reads it, under every rule.`;
+  const p = parseFacts(text);
+  return p.ok ? p.facts : `${factsRelOf(root)}/${repo}.jsonl does not read as facts (${p.issues[0]?.message ?? "?"}).`;
+}
+async function topUpOf(root, repo, o) {
+  const plan = await loadReadPlan(root, repo);
+  const builtin = rulesLacking(plan?.rules);
+  const org = orgRulesLacking(plan?.rules, await effectiveRules(root, repo)).filter((r) => r.files?.length);
+  const lacking = [...builtin, ...org.map((r) => r.id)];
+  if (!lacking.length)
+    return { lacking, files: [], ...plan ? { plan } : {} };
+  const facts = o.facts?.length ? [...o.facts] : await factsOf(root, repo);
+  if (typeof facts === "string")
+    return { error: facts };
+  if (!facts.length)
+    return { error: `${repo} isn't read yet: atticus map ${repo} reads it.` };
+  if (!facts.every((f) => sameCommit(f.commit, o.commit)))
+    return {
+      error: `${repo}'s clone moved past its facts' commit: read what changed first (atticus map ${repo}), then top it up.`
+    };
+  const all = planBatches(o.source, {
+    room: Number.MAX_SAFE_INTEGER,
+    exclude: o.exclude,
+    ...o.conventions ? { conventions: o.conventions } : {}
+  });
+  const reach = reachPlanOf({
+    paths: all.batches.flat().map((x) => x.path),
+    source: o.source,
+    facts,
+    mode: await modelsModeOf(root, repo, o.models)
+  });
+  const files = topUpFiles({
+    facts,
+    source: o.source,
+    exclude: o.exclude,
+    sets: builtin,
+    ...o.conventions ? { conventions: o.conventions } : {},
+    reach
+  });
+  if (org.length) {
+    const byPath = new Map(files.map((f) => [f.path, f]));
+    for (const slice of all.batches.flat()) {
+      if (readingRank(slice.path) === 5)
+        continue;
+      const ids = org.filter((r) => r.files?.length && ruleMatches(r, slice.path)).map((r) => r.id);
+      if (!ids.length)
+        continue;
+      const f = byPath.get(slice.path);
+      if (f)
+        f.sets.push(...ids);
+      else {
+        const add = { path: slice.path, tokens: slice.tokens, lines: slice.of, sets: ids };
+        byPath.set(slice.path, add);
+        files.push(add);
+      }
+    }
+  }
+  return { lacking, files, reach, ...plan ? { plan } : {} };
+}
+var planOr = (plan, repo, commit, session) => plan ?? { schemaVersion: 2, repo, commit, session, plannedAt: stamp(), parts: [] };
+async function recordRulesNow(root, repo, commit, given) {
+  const plan = await loadReadPlan(root, repo);
+  const { topUp: _t, ...rest } = planOr(plan, repo, commit, 15e4);
+  const org = given ? [...plan?.rules?.sets ?? [], ...given] : ruleIds(await effectiveRules(root, repo));
+  const rules = withOrgIds(rulesNow(), org);
+  if (plan?.rules?.hash === FACT_RULES_HASH && !plan.topUp && rules.sets.every((x) => plan.rules.sets.includes(x)))
+    return;
+  await saveReadPlan(root, { ...rest, rules });
+}
+async function writtenHash(root, repo) {
+  const h = createHash("sha256");
+  for (const f of [`${repo}.jsonl`, `${repo}.reviewed.jsonl`])
+    h.update(await readFile(join(factsDirOf(root), f), "utf8").catch(() => "")).update("\0");
+  return h.digest("hex").slice(0, 16);
+}
+async function recordTopUpVerified(root, repo, o) {
+  const plan = await loadReadPlan(root, repo);
+  const t = plan?.topUp;
+  if (!plan || !t || !o.commit || !sameCommit(t.commit, o.commit))
+    return;
+  const now = await writtenHash(root, repo);
+  const doneNow = (s) => !!s.given && !s.done && (s.before === void 0 || s.before !== now);
+  if (!t.sessions.some(doneNow))
+    return;
+  const at = o.now ?? stamp();
+  const sessions = t.sessions.map((s) => doneNow(s) ? { ...s, done: { at, commit: o.commit } } : s);
+  if (sessions.every((s) => s.done)) {
+    const { topUp: _t, ...rest } = plan;
+    const sets = [.../* @__PURE__ */ new Set([...plan.rules?.sets ?? [], ...t.sets])];
+    await saveReadPlan(root, {
+      ...rest,
+      rules: t.hash === FACT_RULES_HASH ? withOrgIds(rulesNow(), sets) : { hash: t.hash, sets }
+    });
+    return;
+  }
+  await saveReadPlan(root, { ...plan, topUp: { ...t, sessions } });
+}
+var withOrgIds = (r, had) => ({
+  hash: r.hash,
+  sets: [...r.sets, ...[...new Set(had.filter((x) => x.startsWith("org:")))].sort()]
+});
+var rulesRelOf = (root, repo) => `${factsRelOf(root)}/${repo}.rules.md`;
+var sameSets = (a, b) => a.length === b.length && a.every((x) => b.includes(x));
+async function plannedTopUp(root, repo, o) {
+  const t = await topUpOf(root, repo, o);
+  if ("error" in t)
+    return t;
+  if (!t.lacking.length)
+    return { lacking: [], facts: [] };
+  const facts = await factsOf(root, repo);
+  if (typeof facts === "string")
+    return { error: facts };
+  if (!o.dryRun && t.reach)
+    await recordNotReached(root, repo, {
+      commit: o.commit,
+      session: o.session,
+      models: t.reach.mode,
+      ...t.reach.notReached ? { notReached: t.reach.notReached } : {}
+    });
+  const reach = t.reach ? { reach: t.reach } : {};
+  const on = (await loadReadPlan(root, repo))?.topUp;
+  const same = on && sameCommit(on.commit, o.commit) && on.hash === FACT_RULES_HASH && sameSets(on.sets, t.lacking);
+  if (same && (!o.models || on.models === o.models))
+    return { lacking: t.lacking, topUp: on, facts, ...reach };
+  const doneSessions = same ? on.sessions.filter((s) => s.done) : [];
+  const read = new Set(doneSessions.flatMap((s) => s.paths));
+  const topUp = {
+    commit: o.commit,
+    hash: FACT_RULES_HASH,
+    sets: t.lacking,
+    session: o.session,
+    plannedAt: stamp(),
+    ...o.models ? { models: o.models } : {},
+    sessions: [
+      ...doneSessions,
+      ...topUpSessions(t.files.filter((f) => !read.has(f.path)), o.session)
+    ]
+  };
+  if (!o.dryRun && topUp.sessions.length)
+    await saveReadPlan(root, {
+      ...planOr(await loadReadPlan(root, repo), repo, o.commit, o.session),
+      topUp
+    });
+  return { lacking: t.lacking, topUp, facts, ...reach };
+}
+async function mapRules(root, repo, o, io) {
+  const p = await plannedTopUp(root, repo, o);
+  if ("error" in p) {
+    io.err(p.error);
+    return 2;
+  }
+  if (!p.lacking.length || !p.topUp) {
+    if (o.json)
+      io.out(JSON.stringify({ repo, commit: o.commit, sets: [], sessions: 0 }, null, 2));
+    else
+      io.out(`${repo} was read under the reading rules there are now: nothing to top up.`);
+    return 0;
+  }
+  const t = p.topUp;
+  if (!t.sessions.length) {
+    await recordRulesNow(root, repo, o.commit, t.sets);
+    if (o.json)
+      io.out(JSON.stringify({ repo, commit: o.commit, sets: t.sets, sessions: 0 }, null, 2));
+    else
+      io.out(`No file of ${repo} is one the reading rules added since it was read apply to (${t.sets.join(", ")}): its read is recorded as under the rules there are now.`);
+    return 0;
+  }
+  const n = t.sessions.findIndex((s) => !s.done);
+  const next = t.sessions[n];
+  const before = await writtenHash(root, repo);
+  const sessions = t.sessions.map((s, i) => i === n ? { ...s, given: stamp(), ...s.given && s.before ? {} : { before } } : s);
+  const plan = await loadReadPlan(root, repo);
+  await saveReadPlan(root, { ...plan, topUp: { ...t, sessions } });
+  const rel = rulesRelOf(root, repo);
+  await writeFileAtomic(join(factsDirOf(root), `${repo}.rules.md`), rulesPrompt(repo, o.commit, {
+    orgRules: await effectiveRules(root, repo),
+    rel: factsRelOf(root),
+    session: next,
+    n: n + 1,
+    of: t.sessions.length,
+    facts: p.facts,
+    notes: o.notes,
+    ...o.checkout ? { checkout: o.checkout } : {},
+    ...p.reach ? { reach: p.reach } : {}
+  }));
+  if (o.json) {
+    io.out(JSON.stringify({
+      repo,
+      commit: o.commit,
+      sets: t.sets,
+      session: n + 1,
+      sessions: t.sessions.length,
+      paths: next.paths,
+      tokens: next.tokens,
+      prompt: rel
+    }, null, 2));
+    return 0;
+  }
+  const files = new Set(t.sessions.flatMap((s) => s.paths.map((x) => lineRangeOf(x)?.file ?? x)));
+  const tokens = t.sessions.reduce((x, s) => x + s.tokens, 0);
+  io.out(`Top-up of ${repo} for the reading rules added since it was read (${t.sets.join(", ")}): ${files.size} ${files.size === 1 ? "file" : "files"}, about ${tokens.toLocaleString("en-US")} tokens, in ${t.sessions.length} ${t.sessions.length === 1 ? "session" : "sessions"} of ${o.session.toLocaleString("en-US")} at most.`);
+  io.out(`Wrote ${rel}: session ${n + 1} of ${t.sessions.length}, ${next.paths.length} ${next.paths.length === 1 ? "read" : "reads"} (${next.sets.join(", ")}), about ${next.tokens.toLocaleString("en-US")} tokens.`);
+  io.out(`Start a new chat, so the session holds only these files, and run /atticus-map ${repo} --rules there (or paste ${rel}). When atticus verify ${repo} passes after it, the session is done${t.sessions.length > n + 1 ? `; the next is for another new chat` : ` and the read records the rules there are now`}.`);
+  return 0;
+}
+var factLine = (f) => `- ${f.id} (${f.kind}, ${f.cite.file}:${f.cite.line})`;
+function rulesPrompt(repo, commit, c) {
+  const s = c.session;
+  const sets = s.sets.filter((x) => RULE_SETS.includes(x));
+  const orgIds = new Set(s.sets.filter((x) => x.startsWith("org:")));
+  const files = s.paths.map((x) => lineRangeOf(x)?.file ?? x);
+  const list = s.paths.map((x) => `- \`${x}\``).join("\n");
+  const kept = c.facts.filter((f) => citedFiles(f).some((p) => files.includes(p)));
+  const block = (id, kind, origin, text) => wrapData({ id, kind, origin }, neutralise(text, void 0, { mark: true }).text);
+  return [
+    `# Top-up of ${repo} at ${commit}`,
+    "",
+    `Session ${c.n} of ${c.of}, about ${s.tokens.toLocaleString("en-US")} tokens of source. ${topUpWords(s.sets.map((x) => x.startsWith("org:") ? x.slice(4).split("@")[0] : x))} Open each path below and nothing else: a path ending \`#L<from>-L<to>\` by those lines only, never the whole file.${c.checkout ? ` The paths are in the repo's checkout, \`${c.checkout}\` in this metarepo: open \`${c.checkout}/<path>\` with your file tools; there is no need to look for it or to run a command.` : ""}`,
+    "",
+    `- Write each fact to \`${c.rel}/${repo}.jsonl\`, appended, with \`commit\` ${commit}. A kept fact you add to is written again whole, under its id.`,
+    `- A path that has nothing to add under these rules: a line in \`${c.rel}/${repo}.reviewed.jsonl\`, \`{"path": "<the path>", "why": "..."}\`. Every path below ends with a fact written or a line there.`,
+    `- Then run \`atticus verify ${repo}\` and fix what it rejects until it exits 0: that records this session done${c.of > c.n ? `. The next session is for a new chat: \`/atticus-map ${repo} --rules\` there` : ", and the read as under the rules there are now"}.`,
+    "",
+    "## The rules",
+    "",
+    "Each fact has this shape:",
+    "",
+    factsReference(),
+    "",
+    factRulesFor(kindsOf(files), void 0, sets),
+    "",
+    ...orgIds.size && c.orgRules ? [readingRulesText({ rules: c.orgRules.rules, builtinOff: [] }, orgIds), ""] : [],
+    "## Read",
+    "",
+    `The paths to open are in the data block below. ${DATA_RULE}`,
+    "",
+    block(`${repo}.rules`, "rules", `${c.rel}/${repo}.read-plan.yaml`, list),
+    "",
+    "## Facts already kept (by id; don't write them again)",
+    "",
+    kept.length ? block(`${repo}.kept`, "facts", `${c.rel}/${repo}.jsonl`, kept.map(factLine).join("\n")) : "None cite these files.",
+    ...c.notes ? [
+      "",
+      "## The organisation's notes for this repo",
+      "",
+      block(`${repo}.notes`, "notes", "org-pack", c.notes)
+    ] : [],
+    "",
+    ...modelsPart(repo, c.reach, new Set(files))
+  ].join("\n");
+}
+function modelsPart(repo, r, files) {
+  const data = r ? modelsData(repo, r, { only: files }) : void 0;
+  return data ? ["## Model classes", "", MODELS_RULE, "", data, ""] : [];
+}
+
+export {
+  topUpFiles,
+  ruleSetsOfFiles,
+  topUpSessions,
+  topUpOf,
+  recordRulesNow,
+  recordTopUpVerified,
+  rulesRelOf,
+  plannedTopUp,
+  mapRules,
+  rulesPrompt
+};