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

package/dist/chunk-MD7KUEJ3.js

@@ -0,0 +1,514 @@
+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 {
+  readReviewed
+} from "./chunk-Q46QDDMF.js";
+import {
+  lineRangeOf
+} from "./chunk-JYMIB5XY.js";
+import {
+  globToRegExp
+} from "./chunk-7AB6OWTV.js";
+import {
+  citedFiles,
+  external_exports,
+  factsDirOf,
+  factsRelOf,
+  parseFacts,
+  require_dist
+} from "./chunk-PAINMSID.js";
+import {
+  writeFileAtomic
+} from "./chunk-ODMBPDDV.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/map-parts.js
+var import_yaml = __toESM(require_dist(), 1);
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+var ReadStamp = external_exports.strictObject({ at: external_exports.string().min(1), commit: external_exports.string().min(1) });
+var Part = external_exports.strictObject({
+  part: external_exports.number().int().positive(),
+  paths: external_exports.array(external_exports.string().min(1)).min(1),
+  files: external_exports.number().int().nonnegative(),
+  /** An estimate: the tokens the part's source counts as (`estimateTokens`), not a meter. */
+  tokens: external_exports.number().int().nonnegative(),
+  /** ADR 0141 (v2): when `atticus verify` first found every unit of the part in the facts. */
+  read: ReadStamp.optional()
+});
+var PlanV1 = external_exports.strictObject({
+  schemaVersion: external_exports.literal(1),
+  repo: external_exports.string().min(1),
+  commit: external_exports.string().min(1),
+  session: external_exports.number().int().positive(),
+  plannedAt: external_exports.string().min(1),
+  parts: external_exports.array(Part.omit({ read: true })).min(1)
+});
+var Reported = external_exports.strictObject({
+  at: external_exports.string().min(1),
+  /** The commit the read was of. */
+  commit: external_exports.string().min(1),
+  tokens: external_exports.number().int().positive().optional(),
+  sessions: external_exports.number().int().positive().optional(),
+  /** The part the report is for, when it is for one. */
+  part: external_exports.number().int().positive().optional(),
+  /** Who reported it (--by), when given. */
+  by: external_exports.string().min(1).optional()
+});
+var RulesRecord = external_exports.strictObject({
+  hash: external_exports.string().min(1),
+  sets: external_exports.array(external_exports.string().min(1))
+});
+var TopUpSession = external_exports.strictObject({
+  paths: external_exports.array(external_exports.string().min(1)).min(1),
+  sets: external_exports.array(external_exports.string().min(1)).min(1),
+  files: external_exports.number().int().nonnegative(),
+  tokens: external_exports.number().int().nonnegative(),
+  /** When `atticus map <repo> --rules` last gave it to a reader. */
+  given: external_exports.string().min(1).optional(),
+  /**
+   * beta.17: a hash of the repo's facts and reviewed lines when it was given; a verify finds it
+   * done only once they differ (something was written for it).
+   */
+  before: external_exports.string().min(1).optional(),
+  /** When a verify that passed after it was given found it done. */
+  done: ReadStamp.optional()
+});
+var TopUp = external_exports.strictObject({
+  commit: external_exports.string().min(1),
+  hash: external_exports.string().min(1),
+  sets: external_exports.array(external_exports.string().min(1)),
+  session: external_exports.number().int().positive(),
+  plannedAt: external_exports.string().min(1),
+  /** beta.15: the model classes it was planned to read (`--models`), when one was asked for. */
+  models: external_exports.enum(["entries", "reachable", "all"]).optional(),
+  sessions: external_exports.array(TopUpSession)
+});
+var MODELS_MODES = ["entries", "reachable", "all"];
+var NotReached = external_exports.strictObject({
+  why: external_exports.string().min(1),
+  files: external_exports.array(external_exports.string().min(1)),
+  tokens: external_exports.number().int().nonnegative(),
+  /**
+   * ADR 0170 (`--models entries`): those of `files` an outbound client reaches but no entry point
+   * does, with why; `--models reachable` reads them.
+   */
+  clientOnly: external_exports.strictObject({ why: external_exports.string().min(1), files: external_exports.array(external_exports.string().min(1)) }).optional()
+});
+var ReadPlanFile = external_exports.strictObject({
+  /** 2 since ADR 0141 (a v1 file reads as v2: `migrateReadPlan`). */
+  schemaVersion: external_exports.literal(2),
+  repo: external_exports.string().min(1),
+  /** The commit the plan was made at; the plan is stale at another commit. */
+  commit: external_exports.string().min(1),
+  /** The session token budget the parts were planned for (`sessionTokensFor`). */
+  session: external_exports.number().int().positive(),
+  plannedAt: external_exports.string().min(1),
+  /**
+   * ADR 0141: what `--estimate` counted for the read (an estimate, not a meter): its source files
+   * and tokens, and the sessions planned (the parts, or one). `reread` when the read is of the
+   * files changed since the facts' commit only (addendum A-incremental).
+   */
+  estimate: external_exports.strictObject({
+    files: external_exports.number().int().nonnegative(),
+    tokens: external_exports.number().int().nonnegative(),
+    sessions: external_exports.number().int().positive(),
+    reread: external_exports.literal(true).optional()
+  }).optional(),
+  /** The parts in the order they are read; none for a repo one session reads (ADR 0141). */
+  parts: external_exports.array(Part),
+  /** ADR 0141: when `atticus verify` first found the whole plan in the facts. */
+  read: ReadStamp.extend({ sessions: external_exports.number().int().positive() }).optional(),
+  /** ADR 0141: what the reader reported the read took (`atticus map <repo> --spent`). */
+  reported: external_exports.array(Reported).optional(),
+  /** ADR 0167: the reading rules the read was given; none when read before they were recorded. */
+  rules: RulesRecord.optional(),
+  /** ADR 0167: a top-up for the rule sets the read lacked, under way. */
+  topUp: TopUp.optional(),
+  /**
+   * ADR 0169: `all` when a person asked for every model class (`--models all`), ADR 0170:
+   * `entries` for those the entry points reach; left out, the read takes those its entry points
+   * and calls reach.
+   */
+  models: external_exports.enum(MODELS_MODES).optional(),
+  /** ADR 0169: the model files the read leaves out, nothing reaching them. */
+  notReached: NotReached.optional()
+});
+function migrateReadPlan(raw) {
+  const v2 = ReadPlanFile.safeParse(raw);
+  if (v2.success)
+    return v2.data;
+  const v1 = PlanV1.safeParse(raw);
+  if (!v1.success)
+    return void 0;
+  return { ...v1.data, schemaVersion: 2 };
+}
+var readPlanRelOf = (root, repo) => `${factsRelOf(root)}/${repo}.read-plan.yaml`;
+var readPlanPath = (root, repo) => join(factsDirOf(root), `${repo}.read-plan.yaml`);
+function unitOf(glob) {
+  const range = lineRangeOf(glob);
+  if (range)
+    return { glob, dir: range.file.replace(/\/?[^/]*$/, ""), deep: false, range };
+  if (glob === "**")
+    return { glob, dir: "", deep: true };
+  if (glob.endsWith("/**"))
+    return { glob, dir: glob.slice(0, -3), deep: true };
+  if (glob === "*")
+    return { glob, dir: "", deep: false };
+  if (glob.endsWith("/*"))
+    return { glob, dir: glob.slice(0, -2), deep: false };
+  return { glob, dir: glob.replace(/\/?[^/]*$/, ""), deep: false, file: glob };
+}
+function folderOf(path) {
+  const star = path.search(/[*?]/);
+  if (star < 0)
+    return { dir: path.replace(/\/?[^/]*$/, ""), deep: false };
+  return { dir: path.slice(0, star).replace(/\/$/, ""), deep: true };
+}
+var isGlobPath = (p) => /[*?]/.test(p);
+var under = (dir, of) => of === "" || dir === of || dir.startsWith(`${of}/`);
+function globHolds(glob, file) {
+  const u = unitOf(glob);
+  if (u.range)
+    return u.range.file === file;
+  if (!/[*]/.test(glob))
+    return glob === file;
+  const dir = file.replace(/\/?[^/]*$/, "");
+  return u.deep ? under(dir, u.dir) : dir === u.dir;
+}
+var HEADER = "# The parts this repo is read in (ADR 0124 addendum A-ledger), as atticus map --estimate planned them,\n# and what the read cost (ADR 0141): tokens are estimates, reported numbers are the reader's word.\n# Which part is next is read back from the facts; atticus next says it. Atticus writes this file.\n";
+async function saveReadPlan(root, plan) {
+  await writeFileAtomic(readPlanPath(root, plan.repo), `${HEADER}${(0, import_yaml.stringify)(ReadPlanFile.parse(plan), { lineWidth: 0 })}`);
+}
+async function writeReadPlan(root, repo, o) {
+  const plan = {
+    schemaVersion: 2,
+    repo,
+    commit: o.commit,
+    session: o.session,
+    plannedAt: o.now ?? stamp(),
+    ...o.estimate ? { estimate: o.estimate } : {},
+    parts: o.parts.map((p, i) => ({
+      part: i + 1,
+      paths: [...p.paths],
+      files: p.files,
+      tokens: p.tokens
+    })),
+    ...o.reported?.length ? { reported: [...o.reported] } : {},
+    ...o.rules ? { rules: { hash: o.rules.hash, sets: [...o.rules.sets] } } : {},
+    ...o.models && o.models !== "reachable" ? { models: o.models } : {},
+    ...o.notReached?.files.length ? { notReached: o.notReached } : {}
+  };
+  await saveReadPlan(root, plan);
+  return plan;
+}
+var stamp = () => (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+async function recordNotReached(root, repo, o) {
+  const plan = await loadReadPlan(root, repo);
+  const { notReached: _n, models: _m, ...rest } = plan ?? {
+    schemaVersion: 2,
+    repo,
+    commit: o.commit,
+    session: o.session,
+    plannedAt: stamp(),
+    parts: []
+  };
+  const next = {
+    ...rest,
+    ...o.models !== "reachable" ? { models: o.models } : {},
+    ...o.notReached?.files.length ? { notReached: o.notReached } : {}
+  };
+  if (plan && JSON.stringify(plan) === JSON.stringify(next))
+    return;
+  if (!plan && !next.notReached && !next.models)
+    return;
+  await saveReadPlan(root, next);
+}
+async function modelsModeOf(root, repo, asked) {
+  return asked ?? (await loadReadPlan(root, repo))?.models ?? "reachable";
+}
+async function loadReadPlan(root, repo) {
+  const text = await readFile(readPlanPath(root, repo), "utf8").catch(() => void 0);
+  if (text === void 0)
+    return void 0;
+  try {
+    return migrateReadPlan((0, import_yaml.parse)(text));
+  } catch {
+    return void 0;
+  }
+}
+function citedLines(x, out = []) {
+  if (Array.isArray(x))
+    for (const v of x)
+      citedLines(v, out);
+  else if (x && typeof x === "object") {
+    const o = x;
+    if (typeof o.file === "string" && typeof o.line === "number")
+      out.push({ file: o.file, line: o.line });
+    for (const v of Object.values(o))
+      if (v && typeof v === "object")
+        citedLines(v, out);
+  }
+  return out;
+}
+async function coveredOf(root, repo) {
+  const out = /* @__PURE__ */ new Set();
+  const reviewed = /* @__PURE__ */ new Set();
+  const lines = [];
+  const ranges = /* @__PURE__ */ new Set();
+  const text = await readFile(join(factsDirOf(root), `${repo}.jsonl`), "utf8").catch(() => void 0);
+  if (text !== void 0) {
+    const parsed = parseFacts(text);
+    const facts = parsed.ok ? parsed.facts : [];
+    for (const f of facts) {
+      for (const p of citedFiles(f))
+        out.add(p);
+      citedLines(f, lines);
+    }
+  }
+  for (const e of (await readReviewed(root, repo)).entries)
+    if (lineRangeOf(e.path))
+      ranges.add(e.path);
+    else {
+      out.add(e.path);
+      reviewed.add(e.path);
+    }
+  return { paths: [...out], reviewed, lines, ranges };
+}
+async function readPlanProgress(root, repo, o = {}) {
+  const plan = await loadReadPlan(root, repo);
+  if (!plan || !plan.parts.length)
+    return void 0;
+  return progressOf(plan, await coveredOf(root, repo), o);
+}
+function ownStarts(plan) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const p of plan.parts)
+    for (const glob of p.paths) {
+      const r = lineRangeOf(glob);
+      if (r)
+        byFile.set(r.file, [...byFile.get(r.file) ?? [], { glob, from: r.from, to: r.to }]);
+    }
+  const out = /* @__PURE__ */ new Map();
+  for (const rs of byFile.values()) {
+    rs.sort((a, b) => a.from - b.from || a.to - b.to);
+    let end = 0;
+    for (const r of rs) {
+      out.set(r.glob, Math.min(r.to, Math.max(r.from, end + 1)));
+      end = Math.max(end, r.to);
+    }
+  }
+  return out;
+}
+function progressOf(plan, of, o) {
+  const repo = plan.repo;
+  const covered = of.paths.map(folderOf);
+  const own = ownStarts(plan);
+  const parts = plan.parts.map((p) => {
+    const units = p.paths.map(unitOf);
+    const hit = (u) => {
+      if (u.range) {
+        const r = u.range;
+        const start = own.get(u.glob) ?? r.from;
+        return of.ranges.has(u.glob) || of.lines.some((l) => l.file === r.file && l.line >= start && l.line <= r.to) || // The whole file reviewed, or a folder glob reviewed over it.
+        of.reviewed.has(r.file) || [...of.reviewed].some((c) => folderOf(c).deep && under(u.dir, folderOf(c).dir));
+      }
+      if (u.file)
+        return of.paths.includes(u.file) || [...of.reviewed].some((c) => isGlobPath(c) && globToRegExp(c).test(u.file));
+      return covered.some((c) => u.deep ? under(c.dir, u.dir) : c.dir === u.dir || c.deep && under(u.dir, c.dir));
+    };
+    if (p.read)
+      return { ...p, state: "done", covered: p.paths, left: [] };
+    const yes = units.filter(hit).map((u) => u.glob);
+    const no = units.filter((u) => !hit(u)).map((u) => u.glob);
+    return {
+      ...p,
+      state: no.length === 0 ? "done" : yes.length ? "in-progress" : "to-read",
+      covered: yes,
+      left: no
+    };
+  });
+  const done = parts.filter((p) => p.state === "done").length;
+  const next = parts.find((p) => p.state !== "done");
+  return {
+    repo,
+    commit: plan.commit,
+    session: plan.session,
+    plannedAt: plan.plannedAt,
+    parts,
+    total: parts.length,
+    done,
+    ...next ? { next } : {},
+    stale: o.commit !== void 0 && o.commit !== plan.commit
+  };
+}
+function partUnaccounted(part, unknown) {
+  const out = [];
+  for (const glob of part.paths) {
+    if (lineRangeOf(glob)) {
+      if (part.left.includes(glob))
+        out.push({ glob, files: [] });
+      continue;
+    }
+    const files = unknown.filter((f) => globHolds(glob, f));
+    if (files.length)
+      out.push({ glob, files });
+  }
+  return out;
+}
+var partOfWords = (p) => `part ${p.part} of ${p.total}`;
+var sameCommit = (a, b) => a.startsWith(b) || b.startsWith(a);
+async function recordReadProgress(root, repo, o) {
+  const plan = await loadReadPlan(root, repo);
+  if (!plan || !o.commit || !sameCommit(plan.commit, o.commit))
+    return void 0;
+  const at = o.now ?? stamp();
+  const read = { at, commit: o.commit };
+  let changed = false;
+  let parts = plan.parts;
+  let whole = plan.parts.length === 0 && o.kept > 0;
+  if (plan.parts.length) {
+    const progress = progressOf(plan, await coveredOf(root, repo), {});
+    parts = plan.parts.map((p, i) => {
+      const state = progress.parts[i];
+      if (p.read)
+        return p;
+      if (state.state !== "done" && !(o.unknown && !partUnaccounted(state, o.unknown).length))
+        return p;
+      changed = true;
+      return { ...p, read };
+    });
+    whole = parts.every((p) => p.read);
+  }
+  const next = {
+    ...plan,
+    parts,
+    ...whole && !plan.read ? { read: { ...read, sessions: plan.parts.length || 1 } } : plan.read ? { read: plan.read } : {}
+  };
+  if (whole && !plan.read)
+    changed = true;
+  if (!changed)
+    return plan;
+  await saveReadPlan(root, next);
+  return next;
+}
+async function recordReported(root, repo, r) {
+  const plan = await loadReadPlan(root, repo);
+  if (!plan)
+    return void 0;
+  const entry = {
+    at: r.at ?? stamp(),
+    commit: plan.commit,
+    ...r.tokens ? { tokens: r.tokens } : {},
+    ...r.sessions ? { sessions: r.sessions } : {},
+    ...r.part ? { part: r.part } : {},
+    ...r.by ? { by: r.by } : {}
+  };
+  const next = { ...plan, reported: [...plan.reported ?? [], entry] };
+  await saveReadPlan(root, next);
+  return next;
+}
+function readCostOf(plan) {
+  const ofCommit = (plan.reported ?? []).filter((r) => sameCommit(r.commit, plan.commit));
+  const sum = (k) => ofCommit.some((r) => r[k] !== void 0) ? ofCommit.reduce((n, r) => n + (r[k] ?? 0), 0) : void 0;
+  const tokens = sum("tokens");
+  const sessions = sum("sessions");
+  const of = plan.parts.length || 1;
+  return {
+    commit: plan.commit,
+    session: plan.session,
+    ...plan.estimate ? { estimated: plan.estimate } : {},
+    read: {
+      parts: plan.parts.length ? plan.parts.filter((p) => p.read).length : plan.read ? 1 : 0,
+      of,
+      ...plan.read ? { at: plan.read.at } : {}
+    },
+    ...ofCommit.length ? {
+      reported: {
+        ...tokens !== void 0 ? { tokens } : {},
+        ...sessions !== void 0 ? { sessions } : {},
+        reports: ofCommit.length
+      }
+    } : {}
+  };
+}
+var tokensWords = (n) => n >= 1e6 ? `${(n / 1e6).toFixed(1).replace(/\.0$/, "")}M` : n >= 1e3 ? `${Math.round(n / 1e3)}K` : String(n);
+function readCostWords(c) {
+  const out = [];
+  if (c.estimated)
+    out.push(`estimated about ${tokensWords(c.estimated.tokens)} tokens in ${c.estimated.sessions} session${c.estimated.sessions === 1 ? "" : "s"}${c.estimated.reread ? " (a re-read)" : ""}`);
+  if (c.read.of > 1 || c.read.parts)
+    out.push(c.read.at ? `read in ${c.read.of} part${c.read.of === 1 ? "" : "s"}` : `${c.read.parts} of ${c.read.of} part${c.read.of === 1 ? "" : "s"} read`);
+  if (c.reported)
+    out.push(`reported ${[
+      c.reported.tokens !== void 0 ? `${tokensWords(c.reported.tokens)} tokens` : "",
+      c.reported.sessions !== void 0 ? `${c.reported.sessions} session${c.reported.sessions === 1 ? "" : "s"}` : ""
+    ].filter(Boolean).join(" in ")}`);
+  return out.join("; ");
+}
+async function mapSpent(root, repo, o, io) {
+  const count = (v, what) => {
+    if (v === void 0)
+      return void 0;
+    const n = Number(v.replace(/[_,]/g, "").replace(/k$/i, "000"));
+    if (Number.isInteger(n) && n > 0)
+      return n;
+    io.err(`${what} is a whole number above 0 (got ${v}).`);
+    return false;
+  };
+  const tokens = count(o.spent, "--spent");
+  const sessions = count(o.sessions, "--sessions");
+  const part = count(o.part, "--part");
+  if (tokens === false || sessions === false || part === false)
+    return 2;
+  if (tokens === void 0 && sessions === void 0) {
+    io.err("Usage: atticus map <repo> --spent <tokens> [--sessions n] [--part n]");
+    return 2;
+  }
+  const plan = await loadReadPlan(root, repo);
+  if (!plan) {
+    io.err(`${repo} has no read plan (${readPlanRelOf(root, repo)}) to record it in: run atticus map ${repo} --estimate first; it records the estimate the read is compared with.`);
+    return 2;
+  }
+  if (part !== void 0 && !plan.parts.some((p) => p.part === part)) {
+    io.err(`${repo}'s read plan has ${plan.parts.length ? `parts 1 to ${plan.parts.length}` : "no parts (one session reads it)"}: there is no part ${part}.`);
+    return 2;
+  }
+  const next = await recordReported(root, repo, {
+    ...tokens ? { tokens } : {},
+    ...sessions ? { sessions } : {},
+    ...part ? { part } : {},
+    ...o.by ? { by: o.by } : {}
+  });
+  const cost = readCostOf(next);
+  io.out(`Recorded in ${readPlanRelOf(root, repo)}, as reported (Atticus meters nothing): ${readCostWords(cost)}.`);
+  return 0;
+}
+
+export {
+  MODELS_MODES,
+  ReadPlanFile,
+  migrateReadPlan,
+  readPlanRelOf,
+  globHolds,
+  saveReadPlan,
+  writeReadPlan,
+  recordNotReached,
+  modelsModeOf,
+  loadReadPlan,
+  readPlanProgress,
+  ownStarts,
+  partUnaccounted,
+  partOfWords,
+  recordReadProgress,
+  recordReported,
+  readCostOf,
+  tokensWords,
+  readCostWords,
+  mapSpent
+};

package/dist/{chunk-66YVAGGM.js → chunk-MMZUN7ZO.js}

@@ -12,27 +12,27 @@ import {
   snowSubmit,
   storyBarCommand,
   templatesDraft
-} from "./chunk-AA6YULYB.js";
-import "./chunk-BWZ77RQT.js";
+} from "./chunk-I2A3Z5AK.js";
+import "./chunk-F6H2RJ3N.js";
+import "./chunk-BEPCKDCP.js";
+import "./chunk-HWD4JPU7.js";
+import "./chunk-5WERBKLE.js";
 import "./chunk-VOGCSYOI.js";
-import "./chunk-CKSITVS4.js";
-import "./chunk-L6SGQIR3.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-T6AIP7H5.js";
-import "./chunk-EFHQ3TWP.js";
-import "./chunk-GQ4N4WKF.js";
-import "./chunk-CNUKCS2T.js";
-import "./chunk-S2A7YC3Q.js";
-import "./chunk-D3PO4DOZ.js";
+import "./chunk-K332XW7K.js";
+import "./chunk-HSZMPH5T.js";
+import "./chunk-D2WSW4GU.js";
+import "./chunk-4KNOJC6J.js";
+import "./chunk-4SLBCEPD.js";
+import "./chunk-64AADMTW.js";
+import "./chunk-JYMIB5XY.js";
+import "./chunk-CPK7QSBG.js";
+import "./chunk-YO2PKTXT.js";
+import "./chunk-TWQRPM76.js";
+import "./chunk-XOL3GFW2.js";
+import "./chunk-QHJJMZLX.js";
+import "./chunk-7AB6OWTV.js";
+import "./chunk-PAINMSID.js";
+import "./chunk-ODMBPDDV.js";
 import "./chunk-TV45EUGM.js";
 export {
   adoSync,