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

package/dist/chunk-HB6XSGI6.js

@@ -0,0 +1,131 @@
+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 "./chunk-XIWYUQZQ.js";
+import "./chunk-P3TKKBAH.js";
+import {
+  repoFor
+} from "./chunk-XKS6THI5.js";
+import "./chunk-Y5PZHS4K.js";
+import {
+  draftRepoType,
+  matchRepoType
+} from "./chunk-AY2IUF4K.js";
+import "./chunk-6JLPXDWN.js";
+import "./chunk-4GZXS6S2.js";
+import "./chunk-R4TBNKKC.js";
+import "./chunk-NIXVDQVO.js";
+import "./chunk-UR7RMZ3R.js";
+import "./chunk-JF2NSTFO.js";
+import "./chunk-N4QZJJVB.js";
+import "./chunk-PGKHJYOB.js";
+import {
+  fsRepo
+} from "./chunk-MKRBG5EF.js";
+import "./chunk-5XDNUJ4P.js";
+import {
+  RecordId,
+  loadOrgPack,
+  orgPackDirOf,
+  require_dist
+} from "./chunk-577AJVRS.js";
+import "./chunk-D3PO4DOZ.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/repo-type-commands.js
+var import_yaml = __toESM(require_dist(), 1);
+import { mkdir, stat, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+var pct = (n) => `${Math.round(n * 100)}%`;
+var notFound = (target) => `${target} isn't a cloned repo of the manifest or a folder; clone it with atticus workspace sync, or give its folder.`;
+function verdictLine(id, r) {
+  const best = r.matches.find((m) => m.type === r.best);
+  switch (r.verdict) {
+    case "clear":
+      return `${id} is a clear match for ${best.name} (${best.type}), ${pct(best.score)}. Reuse it: atticus scan survey ${id} hands its settings and skills to your assistant.`;
+    case "partial":
+      return `${id} is a partial match for ${best.name} (${best.type}), ${pct(best.score)}. Reuse it, and extend the type with what this repo does differently.`;
+    case "tie":
+      return `${id} matches ${r.tied.join(" and ")} about as well.${r.fromDescription ? ` Its description says "${r.fromDescription.words}", so ${r.fromDescription.type} is the likelier of them; a person still decides.` : ""} A person decides which it is; then change the types so their fingerprints tell them apart.`;
+    case "none":
+      return `${id} matches no known repo type.${r.fromDescription ? ` Its description says "${r.fromDescription.words}", so ${r.fromDescription.type} may be it, though nothing in its files says so.` : ""} Draft one: atticus repo-type new <id> --from ${id}`;
+  }
+}
+function typeYaml(t) {
+  const doc = new import_yaml.Document(t);
+  (0, import_yaml.visit)(doc, {
+    Seq(_, node) {
+      if (node.items.every((i) => (0, import_yaml.isScalar)(i)))
+        node.flow = true;
+    }
+  });
+  return doc.toString({ lineWidth: 0, flowCollectionPadding: false });
+}
+async function repoTypeDetect(root, target, o, io) {
+  const repo = await repoFor(root, target);
+  if (!repo) {
+    io.err(notFound(target));
+    return 2;
+  }
+  const op = await loadOrgPack(orgPackDirOf(root));
+  const said = op.profiles.flatMap((p) => p.repos?.repos ?? []).find((x) => x.id === repo.id)?.description?.text;
+  const r = await matchRepoType(fsRepo(repo.id, repo.dir, "0".repeat(40)), op.repoTypes, {
+    ...said ? { description: said } : {}
+  });
+  if (o.json) {
+    io.out(JSON.stringify({ repo: repo.id, ...r }, null, 2));
+    return 0;
+  }
+  if (op.repoTypes.length === 0) {
+    io.out(`The org pack has no repo types yet (org-pack/repo-types/<id>/type.yaml). Draft one: atticus repo-type new <id> --from ${repo.id}`);
+    return 0;
+  }
+  io.out(verdictLine(repo.id, r));
+  for (const m of r.matches) {
+    io.out(`  ${m.type}  ${pct(m.score)} (${m.got} of ${m.total})${m.ruledOut ? ", ruled out: a required signal is missing" : ""}`);
+    for (const s of m.signals)
+      io.out(`    ${s.found ? "found  " : "missing"}  ${s.label} (${s.weight}${s.required ? ", required" : ""})${s.found ? `: ${s.evidence.join(", ")}` : ""}`);
+  }
+  return 0;
+}
+async function repoTypeNew(root, id, o, io) {
+  if (!RecordId.safeParse(id).success || !o.from) {
+    io.err("Usage: atticus repo-type new <id> --from <repo> [--force]. The id is a lowercase slug, like forge-spring-service.");
+    return 2;
+  }
+  const repo = await repoFor(root, o.from);
+  if (!repo) {
+    io.err(notFound(o.from));
+    return 2;
+  }
+  const dir = join(orgPackDirOf(root), "repo-types", id);
+  const file = join(dir, "type.yaml");
+  if (!o.force && await stat(file).catch(() => void 0)) {
+    io.err(`The repo type ${id} already exists (org-pack/repo-types/${id}/type.yaml). Re-run with --force to draft it again.`);
+    return 1;
+  }
+  const t = await draftRepoType(fsRepo(repo.id, repo.dir, "0".repeat(40)), id);
+  if (!t) {
+    io.out(`${repo.id} has no build file, dependency, framework marker or known folder to fingerprint; nothing was written. Write the type by hand.`);
+    return 1;
+  }
+  await mkdir(dir, { recursive: true });
+  const date = (o.now ?? /* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  await writeFile(file, `# Drafted from ${repo.id} by atticus repo-type new on ${date} (ADR 0077). Edit it: name what kind
+# of repo this is, keep the signals every repo of the kind has, set the weights, add skills.
+${typeYaml(t)}`, "utf8");
+  const kinds = /* @__PURE__ */ new Map();
+  for (const s of t.fingerprint)
+    kinds.set(s.kind, (kinds.get(s.kind) ?? 0) + 1);
+  io.out(`Wrote org-pack/repo-types/${id}/type.yaml from ${repo.id}: ${[...kinds].map(([k, n]) => `${n} ${k}`).join(", ")} ${t.fingerprint.length === 1 ? "signal" : "signals"}, ${t.settings.prefixes.length} prefix ${t.settings.prefixes.length === 1 ? "rule" : "rules"}.`);
+  io.out(`Next: edit it, check it with atticus repo-type detect ${repo.id} and atticus orgpack validate, then review it in a pull request.`);
+  return 0;
+}
+export {
+  repoTypeDetect,
+  repoTypeNew
+};

package/dist/chunk-HE4ZQXZM.js

@@ -0,0 +1,396 @@
+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-B3O52AUQ.js";
+import {
+  lineRangeOf
+} from "./chunk-4GZXS6S2.js";
+import {
+  citedFiles,
+  external_exports,
+  factsDirOf,
+  factsRelOf,
+  parseFacts,
+  require_dist
+} from "./chunk-577AJVRS.js";
+import {
+  writeFileAtomic
+} from "./chunk-D3PO4DOZ.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 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()
+});
+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 };
+}
+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 under = (dir, of) => of === "" || dir === of || dir.startsWith(`${of}/`);
+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] } : {}
+  };
+  await saveReadPlan(root, plan);
+  return plan;
+}
+var stamp = () => (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+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));
+      }
+      return covered.some((c) => u.deep ? under(c.dir, u.dir) : c.dir === u.dir || c.deep && under(u.dir, c.dir));
+    };
+    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
+  };
+}
+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) => {
+      if (p.read || progress.parts[i].state !== "done")
+        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 {
+  ReadPlanFile,
+  migrateReadPlan,
+  readPlanRelOf,
+  saveReadPlan,
+  writeReadPlan,
+  loadReadPlan,
+  readPlanProgress,
+  ownStarts,
+  partOfWords,
+  recordReadProgress,
+  recordReported,
+  readCostOf,
+  tokensWords,
+  readCostWords,
+  mapSpent
+};