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

package/dist/chunk-O5PXQR67.js

@@ -0,0 +1,249 @@
+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-LO6P2VYG.js";
+import {
+  draftRepoType,
+  matchRepoType
+} from "./chunk-J2JAKCIW.js";
+import {
+  fsRepo
+} from "./chunk-3NFFJL5D.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,
+  termAnswerNote,
+  termOfQuestion
+} from "./chunk-Q2TECDIT.js";
+import {
+  require_dist
+} from "./chunk-BQGDB6ZL.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-PRPPGYZG.js → chunk-O66DM6DJ.js}

@@ -6,10 +6,12 @@ var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   listRuns,
   runTranscript
-} from "./chunk-DPUYDDQG.js";
-import "./chunk-CNUKCS2T.js";
-import "./chunk-S2A7YC3Q.js";
-import "./chunk-D3PO4DOZ.js";
+} from "./chunk-GZY6RUZ6.js";
+import "./chunk-P32RUW3B.js";
+import "./chunk-QA4O2GGC.js";
+import "./chunk-Q2TECDIT.js";
+import "./chunk-TUULXQRW.js";
+import "./chunk-BQGDB6ZL.js";
 import "./chunk-TV45EUGM.js";
 
 // packages/cli/dist/runs-commands.js

package/dist/{chunk-KEM4SDDP.js → chunk-O7FDLW7L.js}

@@ -10,7 +10,7 @@ import {
   repoComponents,
   resolveSettingsTemplate,
   specTriggers
-} from "./chunk-27NKUS3X.js";
+} from "./chunk-J2JAKCIW.js";
 import {
   BUILT_IN_EXTRACTORS,
   LANG_OF,
@@ -35,17 +35,17 @@ import {
   runFrameworkTests,
   syntaxLanguageOf,
   syntaxOutline
-} from "./chunk-MC3H7736.js";
+} from "./chunk-CQDGOPGH.js";
 import {
   createParseCache,
   fsRepo,
   globToRegExp,
   scanRepo
-} from "./chunk-GQ4N4WKF.js";
+} from "./chunk-3NFFJL5D.js";
 import {
   buildContextPack,
   resumedAttempt
-} from "./chunk-CNUKCS2T.js";
+} from "./chunk-P32RUW3B.js";
 import {
   AgentDefinition,
   Dialect,
@@ -61,15 +61,18 @@ import {
   RecordId,
   ScanSettings,
   VerifyAnswer,
+  answerByWords,
   answerWords,
   external_exports,
   orgPackJsonSchemas,
   parseRecord,
-  require_dist,
   rulesJsonSchemas,
   templateRef,
   toCanonicalYaml
-} from "./chunk-S2A7YC3Q.js";
+} from "./chunk-Q2TECDIT.js";
+import {
+  require_dist
+} from "./chunk-BQGDB6ZL.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";
@@ -2609,7 +2612,7 @@ function askedBefore(questions) {
   if (answered.length) {
     lines.push("Questions a person has answered. Follow these answers in the settings, and don't ask them again:");
     for (const q of answered)
-      lines.push(`- ${q.id}: ${q.question} (${q.evidence.join(", ")})`, `  Answer (${q.answer.by}): ${answerWords(q)}`);
+      lines.push(`- ${q.id}: ${q.question} (${q.evidence.join(", ")})`, `  Answer (${answerByWords(q.answer.by)}): ${answerWords(q)}`);
   }
   if (open.length) {
     lines.push("Questions already asked and waiting for a person. Don't ask them again:");
@@ -3294,7 +3297,7 @@ function askedBefore2(questions) {
   if (answered.length) {
     lines.push("Questions a person has answered. Follow these answers in the flows, and don't ask them again:");
     for (const q of answered)
-      lines.push(`- ${q.id}: ${q.question} (${q.evidence.join(", ")})`, `  Answer (${q.answer.by}): ${answerWords(q)}`);
+      lines.push(`- ${q.id}: ${q.question} (${q.evidence.join(", ")})`, `  Answer (${answerByWords(q.answer.by)}): ${answerWords(q)}`);
   }
   if (open.length) {
     lines.push("Questions already asked and waiting for a person. Don't ask them again:");