@maycombhq/atticus 2.0.0-beta.10 → 2.0.0-beta.12

package/dist/chunk-LDUJ6NIT.js

@@ -0,0 +1,247 @@
+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 {
+  repoFor
+} from "./chunk-7VNEDDCC.js";
+import {
+  draftRepoType,
+  matchRepoType
+} from "./chunk-22GLUHGE.js";
+import {
+  fsRepo
+} from "./chunk-MRLCNXXR.js";
+import {
+  CONVENTIONS_SCHEMA_VERSION,
+  ChecklistPack,
+  Conventions,
+  OrgNote,
+  REPO_TYPE_SCHEMA_VERSION,
+  REVIEW_SCHEMA_VERSION,
+  RULE_WORDS,
+  RecordId,
+  RepoType,
+  TERM_STEP,
+  loadOrgPack,
+  noteKey,
+  noteRuleDrafts,
+  notesFor,
+  orgPackDirOf,
+  require_dist,
+  termAnswerNote,
+  termOfQuestion
+} from "./chunk-U25OX22K.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/repo-type-commands.js
+var import_yaml = __toESM(require_dist(), 1);
+import { mkdir, readFile, 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;
+}
+var noteFileOf = (root, type) => type ? join(orgPackDirOf(root), "repo-types", type, "type.yaml") : join(orgPackDirOf(root), "conventions.yaml");
+var noteRel = (type) => type ? `org-pack/repo-types/${type}/type.yaml` : "org-pack/conventions.yaml";
+async function repoTypeNote(root, type, o, io) {
+  if (!type && !o.org || type && o.org) {
+    io.err('Usage: atticus repo-type note <type> [--add "..."], or atticus repo-type note --org-wide [--add "..."] for the notes every repo is read with.');
+    return 2;
+  }
+  const file = noteFileOf(root, type);
+  const exists = await stat(file).catch(() => void 0);
+  if (type && !exists) {
+    io.err(`No repo type ${type} (${noteRel(type)}). Draft one: atticus repo-type new ${type} --from <repo>`);
+    return 2;
+  }
+  const doc = exists ? (0, import_yaml.parseDocument)(await readFile(file, "utf8")) : new import_yaml.Document({ schemaVersion: CONVENTIONS_SCHEMA_VERSION });
+  const notes = doc.toJS()?.notes ?? [];
+  if (o.add === void 0) {
+    if (!notes.length)
+      io.out(`${noteRel(type)} has no notes yet. Add one: atticus repo-type note ${type ?? "--org-wide"} --add "..."`);
+    notes.forEach((n, i) => io.out(`${i + 1}. ${String(n)} (note ${noteKey(String(n))})`));
+    return 0;
+  }
+  const note = OrgNote.safeParse(o.add.replace(/\s*[\r\n]+\s*/g, " "));
+  if (!note.success) {
+    io.err("A note is plain text, from 1 to 1000 characters, on one line.");
+    return 2;
+  }
+  if (notes.some((n) => String(n).trim() === note.data)) {
+    io.out(`${noteRel(type)} already has that note.`);
+    return 0;
+  }
+  doc.set("schemaVersion", type ? REPO_TYPE_SCHEMA_VERSION : CONVENTIONS_SCHEMA_VERSION);
+  doc.set("notes", [...notes.map(String), note.data]);
+  const check = (type ? RepoType : Conventions).safeParse(doc.toJS());
+  if (!check.success) {
+    io.err(`${noteRel(type)} doesn't read as it should with the note added: ${check.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`);
+    return 1;
+  }
+  await mkdir(join(file, ".."), { recursive: true });
+  await writeFile(file, doc.toString({ lineWidth: 0 }), "utf8");
+  io.out(`Added note ${notes.length + 1} (note ${noteKey(note.data)}) to ${noteRel(type)}. The next read of ${type ? `each ${type} repo` : "every repo"} is handed it; review it in a pull request.`);
+  if (RULE_WORDS.test(note.data))
+    io.out(`It reads as a rule: atticus repo-type rules drafts a checklist rule from it for a person to review.`);
+  return 0;
+}
+function termNoteOffer(q) {
+  if (q.askedBy.step !== TERM_STEP || !q.answer)
+    return void 0;
+  const about = termOfQuestion(q.question);
+  if (!about)
+    return void 0;
+  const label = q.answer.option ? q.options[q.answer.option - 1]?.label : void 0;
+  const text = termAnswerNote({
+    ...about,
+    ...q.answer.text ? { text: q.answer.text } : {},
+    ...label === "owner" || label === "consumer" || label === "none" ? { option: label } : {}
+  });
+  const type = q.scope.level === "repo-type" ? q.scope.id : void 0;
+  return type ? `Save it as a note on ${type}, so every ${type} repo is read with it: atticus repo-type note ${type} --add ${JSON.stringify(text)}` : `Save it as a note every repo is read with: atticus repo-type note --org-wide --add ${JSON.stringify(text)}`;
+}
+var NOTE_RULES_FILE = "checklists/org-notes.yaml";
+async function repoTypeRules(root, o, io) {
+  const op = await loadOrgPack(orgPackDirOf(root));
+  const notes = [
+    ...op.repoTypes.flatMap((t) => notesFor(t, void 0)),
+    ...notesFor(void 0, op.conventions)
+  ];
+  const drafts = noteRuleDrafts(notes);
+  const file = join(orgPackDirOf(root), ...NOTE_RULES_FILE.split("/"));
+  const onFile = await stat(file).catch(() => void 0) ? ChecklistPack.safeParse((0, import_yaml.parse)(await readFile(file, "utf8"))) : void 0;
+  if (onFile && !onFile.success) {
+    io.err(`org-pack/${NOTE_RULES_FILE} doesn't read as a checklist; fix it first (atticus orgpack validate).`);
+    return 1;
+  }
+  const kept = onFile?.data.rules ?? [];
+  const fresh = drafts.filter((d) => !kept.some((k) => k.id === d.id));
+  if (o.json) {
+    io.out(JSON.stringify({ file: `org-pack/${NOTE_RULES_FILE}`, drafts, fresh: fresh.map((d) => d.id) }, null, 2));
+  } else if (!drafts.length) {
+    io.out('No note reads as a rule (all, every or must). Notes are added with atticus repo-type note <type> --add "...".');
+    return 0;
+  } else
+    for (const d of drafts)
+      io.out(`${d.id}${kept.some((k) => k.id === d.id) ? ` (in org-pack/${NOTE_RULES_FILE}, ${kept.find((k) => k.id === d.id).status})` : " (new draft)"}: ${d.title}
+  check: ${d.check.type === "deterministic" ? `${d.check.check} ${JSON.stringify(d.check.params)}` : "ai"}; from ${d.source}`);
+  if (!o.write) {
+    if (!o.json && fresh.length)
+      io.out(`Write the new drafts with atticus repo-type rules --save, then review them in a pull request.`);
+    return 0;
+  }
+  if (!fresh.length) {
+    if (!o.json)
+      io.out(`org-pack/${NOTE_RULES_FILE} already has every draft.`);
+    return 0;
+  }
+  const pack = ChecklistPack.parse({
+    schemaVersion: REVIEW_SCHEMA_VERSION,
+    name: onFile?.data.name ?? "org-notes",
+    version: onFile?.data.version ?? "0.1.0",
+    description: onFile?.data.description ?? "Rules drafted from the organisation's notes (ADR 0163). A person sets what each checks and makes it active; Atticus never reads the note to check it.",
+    rules: [...kept, ...fresh]
+  });
+  await mkdir(join(file, ".."), { recursive: true });
+  await writeFile(file, `# Drafted by atticus repo-type rules from the org pack's notes (ADR 0163). Review each rule:
+# set its check, then change status from draft to active. Accepted call-security rules are
+# checked at each atticus verify <repo> --write.
+${typeYaml(pack)}`, "utf8");
+  if (!o.json)
+    io.out(`Wrote ${fresh.length} ${fresh.length === 1 ? "draft" : "drafts"} to org-pack/${NOTE_RULES_FILE}; review them in a pull request.`);
+  return 0;
+}
+
+export {
+  repoTypeDetect,
+  repoTypeNew,
+  repoTypeNote,
+  termNoteOffer,
+  NOTE_RULES_FILE,
+  repoTypeRules
+};

package/dist/{chunk-5YIBJXGB.js → chunk-LTLR4JZJ.js}

@@ -12,13 +12,13 @@ import {
   readPlan,
   readView,
   workingDays
-} from "./chunk-UYYN2IUZ.js";
+} from "./chunk-MNUZX67F.js";
 import {
   traceMatrix
-} from "./chunk-7YYEKTYF.js";
+} from "./chunk-DGZXJO5I.js";
 import {
   SYNC_FILE
-} from "./chunk-KC5DROFC.js";
+} from "./chunk-DWYPYVPJ.js";
 import {
   contentLines,
   docOf,
@@ -38,7 +38,7 @@ import {
   sectionLines,
   sectionMatching,
   tableWith
-} from "./chunk-47QE246J.js";
+} from "./chunk-GMDOXWIS.js";
 import {
   changeFolder,
   changeReport,
@@ -47,17 +47,17 @@ import {
   outsideKindOf,
   outsideSystemsOf,
   outsideWords
-} from "./chunk-XQ3YIV5R.js";
+} from "./chunk-U5T4A2QV.js";
 import {
   fileStepStore,
   stepOfProvisional
-} from "./chunk-NGPU2ARF.js";
+} from "./chunk-DW4BM73R.js";
 import {
   readServiceRequestExports
-} from "./chunk-R4TBNKKC.js";
+} from "./chunk-HY2VVVFZ.js";
 import {
   readChangeRepos
-} from "./chunk-PGKHJYOB.js";
+} from "./chunk-RA64IK43.js";
 import {
   BREAKING_SPEC,
   NAMES_SECRET_SPEC,
@@ -67,7 +67,7 @@ import {
   settle,
   tokenFormatIn,
   verdictOf
-} from "./chunk-5XDNUJ4P.js";
+} from "./chunk-CQD26SMZ.js";
 import {
   ChangeOutcomes,
   WORKSPACE_SCHEMA_VERSION,
@@ -77,7 +77,7 @@ import {
   readRunSummary,
   require_dist,
   toCanonicalYaml
-} from "./chunk-577AJVRS.js";
+} from "./chunk-U25OX22K.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";

package/dist/{chunk-IZNSAEBX.js → chunk-MFRPLAOH.js}

@@ -6,14 +6,14 @@ var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   resumedAttempt,
   stepClassOf
-} from "./chunk-5XDNUJ4P.js";
+} from "./chunk-CQD26SMZ.js";
 import {
   RUN_SCHEMA_VERSION,
   STEP_CLASSES,
   changesDirOf,
   runsDirOf,
   runsRelOf
-} from "./chunk-577AJVRS.js";
+} from "./chunk-U25OX22K.js";
 
 // packages/cli/dist/runs-view.js
 import { createHash } from "node:crypto";

package/dist/{chunk-6GWHKMQR.js → chunk-MH7UBG47.js}

@@ -5,10 +5,10 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   factsRepos
-} from "./chunk-3GTZ2OON.js";
+} from "./chunk-BTOGAUWX.js";
 import {
   checkoutOf
-} from "./chunk-B3O52AUQ.js";
+} from "./chunk-P76AW3PA.js";
 import {
   AUDIT_ANSWERS,
   AUDIT_DEFAULT_SIZE,
@@ -26,7 +26,7 @@ import {
   require_dist,
   serializeAuditFile,
   sumAuditPrecision
-} from "./chunk-577AJVRS.js";
+} from "./chunk-U25OX22K.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";
@@ -102,7 +102,7 @@ async function readFactsOf(root, repo) {
   return r.ok ? { facts: r.facts } : { bad: true };
 }
 async function linksOf(root, repo) {
-  const { estateFacts, estateJoinOf, auditLinkCandidates } = await import("./chunk-2XM6PYQQ.js");
+  const { estateFacts, estateJoinOf, auditLinkCandidates } = await import("./chunk-UT5OA7KA.js");
   const op = await loadOrgPack(orgPackDirOf(root));
   const estate = await estateFacts(root, op, "");
   const join2 = estateJoinOf(op, estate.repos, estate.targets);