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

package/dist/chunk-XI2LCCYQ.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-BPK5P77O.js";
+import {
+  effectiveRules,
+  orgRulesLacking,
+  readingRulesText,
+  ruleIds,
+  ruleMatches
+} from "./chunk-WXFLMQSR.js";
+import {
+  loadReadPlan,
+  modelsModeOf,
+  recordNotReached,
+  saveReadPlan
+} from "./chunk-TYQBFTBR.js";
+import {
+  FACT_RULES_HASH,
+  MODELS_RULE,
+  RULE_SETS,
+  factRulesFor,
+  factsReference,
+  ruleSetKinds,
+  rulesLacking,
+  rulesNow,
+  topUpWords
+} from "./chunk-BEVTIBRH.js";
+import {
+  fileKinds,
+  kindsOf,
+  lineRangeOf,
+  planBatches,
+  readingRank,
+  sameCommit
+} from "./chunk-CXJ6FUKN.js";
+import {
+  DATA_RULE,
+  neutralise,
+  wrapData
+} from "./chunk-P32RUW3B.js";
+import {
+  citedFiles,
+  factsDirOf,
+  factsRelOf,
+  parseFacts
+} from "./chunk-Q2TECDIT.js";
+import {
+  writeFileAtomic
+} from "./chunk-TUULXQRW.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
+};