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

package/dist/chunk-7SW2QWLU.js

@@ -0,0 +1,212 @@
+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 {
+  candidateAnnotations,
+  dialectFilePath,
+  exportKit,
+  formatGrade,
+  gradeDialect,
+  loadDialectFile,
+  runDialectOnRepo,
+  scaffoldDialect,
+  surveyRepos,
+  testDialect
+} from "./chunk-KEM4SDDP.js";
+import "./chunk-27NKUS3X.js";
+import "./chunk-L24C55VN.js";
+import "./chunk-PAMPPUR6.js";
+import "./chunk-23W7VWKR.js";
+import "./chunk-7EKXJZ2Y.js";
+import {
+  SYNTAX_LANGUAGES,
+  syntaxLanguageOf,
+  syntaxOutline
+} from "./chunk-MC3H7736.js";
+import "./chunk-EFHQ3TWP.js";
+import "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import {
+  RecordId,
+  orgPackDirOf,
+  require_dist
+} from "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/dialect-commands.js
+var import_yaml = __toESM(require_dist(), 1);
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { join, relative, resolve, sep } from "node:path";
+var plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+var shown = (root, file) => relative(root, file).split(sep).join("/");
+var isDir = (p) => stat(p).then((s) => s.isDirectory()).catch(() => false);
+async function dialectNew(root, name, repoDirs, io) {
+  if (!RecordId.safeParse(name).success) {
+    io.err('A dialect name is a lowercase slug (a-z, 0-9, ".", "_" and "-"), for example: forge-messaging');
+    return 2;
+  }
+  if (repoDirs.length === 0) {
+    io.err("dialect new needs at least one repo folder, for example: atticus dialect new house --from repos/a repos/b");
+    return 2;
+  }
+  const dirs = repoDirs.map((d) => resolve(d));
+  for (const d of dirs) {
+    if (!await isDir(d)) {
+      io.err(`${d} is not a folder.`);
+      return 2;
+    }
+  }
+  const file = join(orgPackDirOf(root), "dialects", `${name}.yaml`);
+  const existing = await dialectFilePath(join(orgPackDirOf(root)), name);
+  if (existing) {
+    io.err(`${shown(root, existing)} already exists; it was left as it is. Choose another name or edit that file.`);
+    return 1;
+  }
+  const survey = await surveyRepos(dirs);
+  await mkdir(join(orgPackDirOf(root), "dialects"), { recursive: true });
+  await writeFile(file, scaffoldDialect(name, survey), { encoding: "utf8", flag: "wx" });
+  const house = survey.annotations.filter((a) => !a.known).length;
+  io.out(`Wrote ${shown(root, file)} from ${plural(survey.repos.length, "repo")}: ${survey.marker ? `marker ${survey.marker}` : "no marker every repo has"}, ${plural(house, "framework annotation")}, ${plural(candidateAnnotations(survey).length, "candidate rule")}, ${plural(survey.configKeys.length, "config key")}.`);
+  io.out(`Next: finish the rules and write tests, then run atticus dialect test ${name}.`);
+  return 0;
+}
+async function load(root, name, io, allowNoTests) {
+  const file = await dialectFilePath(join(orgPackDirOf(root)), name);
+  if (!file) {
+    io.err(`No dialect file org-pack/dialects/${name}.yaml. Create one with: atticus dialect new ${name} --from <repo>...`);
+    return void 0;
+  }
+  const loaded = await loadDialectFile(file, { allowNoTests, checkFileName: true });
+  if (!loaded.dialect) {
+    const yamlProblem = loaded.problems.find((p) => p.path === "" && p.message.startsWith("not valid YAML"));
+    if (yamlProblem)
+      io.err(`${shown(root, file)} is ${yamlProblem.message}`);
+    else {
+      io.err(`${shown(root, file)} is not a valid dialect (contract C2):`);
+      for (const p of loaded.problems)
+        io.err(`  ${p.path ? `${p.path}: ` : ""}${p.message}`);
+    }
+    return void 0;
+  }
+  return loaded;
+}
+async function dialectTest(root, name, io) {
+  const loaded = await load(root, name, io, false);
+  if (!loaded)
+    return 1;
+  const d = loaded.dialect;
+  io.out(`Testing dialect ${d.name} ${d.version}: ${plural(d.rules.length, "rule")}, ${plural(d.tests.length, "test")}`);
+  const results = await testDialect(d, loaded.dir, loaded.parents);
+  for (const r of results) {
+    io.out(`  ${r.passed ? "pass" : "FAIL"}  ${r.name}`);
+    for (const f of r.failures)
+      io.out(`          ${f}`);
+  }
+  const failed = results.filter((r) => !r.passed).length;
+  if (failed === 0) {
+    io.out(`${plural(results.length, "test")} passed.`);
+    return 0;
+  }
+  io.out(`${failed} of ${plural(results.length, "test")} failed. To see what the rules produce from a repo: atticus dialect run ${d.name} <repo>`);
+  return 1;
+}
+function shownFields(record) {
+  const out = {
+    kind: record.kind,
+    id: record.id,
+    confidence: record.confidence
+  };
+  for (const [k, v] of Object.entries(record)) {
+    if (["kind", "id", "confidence", "schemaVersion", "status", "evidence"].includes(k))
+      continue;
+    if (Array.isArray(v) && v.length === 0)
+      continue;
+    if (v && typeof v === "object" && !Array.isArray(v) && Object.keys(v).length === 0)
+      continue;
+    out[k] = v;
+  }
+  return out;
+}
+async function dialectRun(root, name, repoDir, o, io) {
+  const dir = resolve(repoDir);
+  if (!await isDir(dir)) {
+    io.err(`${dir} is not a folder.`);
+    return 2;
+  }
+  const loaded = await load(root, name, io, true);
+  if (!loaded)
+    return 1;
+  const d = loaded.dialect;
+  const run = await runDialectOnRepo(d, loaded.parents, dir);
+  if (o.json) {
+    io.out(JSON.stringify({
+      applies: run.applies,
+      records: run.records.map((r) => r.record),
+      warnings: run.warnings,
+      rejected: run.rejected,
+      ...run.error ? { error: run.error } : {}
+    }, null, 2));
+    return run.rejected.length > 0 || run.error ? 1 : 0;
+  }
+  if (!run.applies) {
+    io.out(`The marker ${d.appliesTo.marker} is not in ${run.repo}, so the dialect does not apply there. 0 records.`);
+    return 0;
+  }
+  if (run.error)
+    io.err(`The dialect failed: ${run.error}`);
+  for (const { record, rule } of run.records) {
+    const fields = shownFields(record);
+    const lines = (0, import_yaml.stringify)([fields], { lineWidth: 0 }).trimEnd().split("\n");
+    for (const l of lines)
+      io.out(l);
+    const ev = record.evidence[0];
+    io.out(`  # from ${ev?.path ?? "?"}:${ev?.line ?? "?"}${rule ? ` (rule ${rule})` : ""}`);
+  }
+  for (const w of run.warnings)
+    io.out(`warning: ${w.message}${w.path ? ` (${w.path})` : ""}`);
+  for (const r of run.rejected) {
+    const rec = r.record;
+    const at = rec.evidence?.[0];
+    io.out(`invalid: ${rec.kind ?? "?"} ${rec.id ?? "?"} from ${at?.path ?? "?"}:${at?.line ?? "?"}: ${r.issues.map((i) => `${i.path ? `${i.path}: ` : ""}${i.message}`).join("; ")}`);
+  }
+  io.out(`${plural(run.records.length, "record")} from ${run.repo}.${loaded.noTests ? " This dialect has no tests yet; atticus dialect test fails until it has one." : ""}`);
+  return run.rejected.length > 0 || run.error ? 1 : 0;
+}
+async function dialectKit(outDir, io) {
+  const files = await exportKit(outDir);
+  io.out(`Wrote the dialect build kit (${files.length} files) to ${outDir}`);
+  return 0;
+}
+async function dialectGrade(file, evalDir, io) {
+  const g = await gradeDialect(resolve(file), resolve(evalDir));
+  for (const l of formatGrade(g))
+    io.out(l);
+  return g.pass ? 0 : 1;
+}
+async function dialectTree(file, o, io) {
+  const lang = o.language ?? syntaxLanguageOf(file);
+  if (!lang || !SYNTAX_LANGUAGES.includes(lang)) {
+    io.err(`No grammar for ${file}${o.language ? ` (${o.language})` : ""}. Grammars: ${SYNTAX_LANGUAGES.join(", ")}.`);
+    return 2;
+  }
+  const text = await readFile(resolve(file), "utf8").catch(() => void 0);
+  if (text === void 0) {
+    io.err(`${file} can't be read.`);
+    return 2;
+  }
+  io.out(await syntaxOutline(lang, text, Number.MAX_SAFE_INTEGER));
+  return 0;
+}
+export {
+  dialectGrade,
+  dialectKit,
+  dialectNew,
+  dialectRun,
+  dialectTest,
+  dialectTree
+};

package/dist/chunk-7WD63HU2.js

@@ -0,0 +1,143 @@
+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 {
+  readRound,
+  reviewedGates,
+  roundsOf
+} from "./chunk-3HI6Z55Y.js";
+import {
+  changeStore,
+  liveHandoff
+} from "./chunk-XY3P7JW7.js";
+import {
+  createAdapters
+} from "./chunk-7JUKDRSZ.js";
+import {
+  loadOrgPack,
+  orgPackDirOf
+} from "./chunk-S2A7YC3Q.js";
+
+// packages/cli/dist/digest-commands.js
+var norm = (s) => s.toLowerCase().replace(/^@/, "");
+async function buildDigest(root, user) {
+  const revise = [];
+  const blocking = [];
+  const changes = await changeStore(root).list().catch(() => []);
+  const me = norm(user);
+  for (const c of changes.sort((a, b) => a.id.localeCompare(b.id))) {
+    const h = liveHandoff(c);
+    if (h?.state === "changes-requested" && norm(h.by) === me)
+      revise.push({
+        change: c.id,
+        title: c.title,
+        phase: h.phase,
+        pr: h.pr.url,
+        openedAt: h.openedAt
+      });
+  }
+  for (const c of changes.sort((a, b) => a.id.localeCompare(b.id))) {
+    if (c.state === "archived")
+      continue;
+    const mine = norm(c.createdBy) === me || Object.values(c.owners ?? {}).some((hs) => hs.some((h) => norm(h) === me));
+    if (!mine)
+      continue;
+    let open = 0;
+    for (const gate of await reviewedGates(root, c.id)) {
+      const rounds = await roundsOf(root, c.id, gate);
+      if (!rounds.length)
+        continue;
+      const round = await readRound(root, c.id, gate, rounds.at(-1));
+      open += round.findings.filter((f) => f.finding.state === "open" && f.finding.severity === "blocking").length;
+    }
+    if (open)
+      blocking.push({ change: c.id, open });
+  }
+  const lines = [];
+  if (revise.length) {
+    lines.push(`${revise.length} hand-off${revise.length === 1 ? "" : "s"} to revise:`);
+    for (const w of revise)
+      lines.push(`- ${w.change} (${w.phase}): ${w.pr}`);
+  }
+  if (blocking.length) {
+    lines.push("Blocking findings on changes you are on:");
+    for (const b of blocking)
+      lines.push(`- ${b.change}: ${b.open} open`);
+  }
+  if (!lines.length)
+    lines.push("Nothing waits on you.");
+  const { readMe } = await import("./chunk-ZMAINWBW.js");
+  const { watchLine } = await import("./chunk-DE76JROX.js");
+  const watching = [];
+  for (const c of (await readMe(root)).watch)
+    watching.push(await watchLine(root, c));
+  if (watching.length)
+    lines.push("Changes you watch:", ...watching.map((w) => `- ${w}`));
+  const n = revise.length + blocking.length;
+  return {
+    title: !n ? "Atticus: nothing waits on you" : n === 1 ? "Atticus: 1 thing waits on you" : `Atticus: ${n} things wait on you`,
+    body: lines.join("\n"),
+    lines,
+    revise,
+    blocking,
+    watching
+  };
+}
+async function digestCommand(root, o, io, deps = {}) {
+  if (!o.as) {
+    io.err("Usage: atticus digest [--as <you>] [--channel <c>] [--send] [--json]");
+    return 2;
+  }
+  const d = await buildDigest(root, o.as);
+  let sent;
+  let notSent;
+  if (o.send) {
+    let notify = deps.notify;
+    if (!notify) {
+      const op = await loadOrgPack(orgPackDirOf(root));
+      const cfg = op.runtime.adapters.notify;
+      if (!cfg)
+        notSent = "No notify adapter is set in org-pack/runtime.yaml (adapters.notify).";
+      else if (cfg.type === "manual")
+        notSent = "Notifications are manual here, so the digest is shown instead of sent.";
+      else
+        try {
+          notify = createAdapters({ adapters: { notify: cfg } }).notify;
+        } catch (e) {
+          notSent = e.message;
+        }
+    }
+    if (notify) {
+      const channel = o.channel ?? `@${o.as}`;
+      try {
+        const r = await notify.send({ channel, title: d.title, body: d.body, mentions: [o.as] }, {
+          by: o.as,
+          at: deps.now ?? (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z"),
+          ref: `digest:${o.as}`
+        });
+        sent = { id: r.id, channel };
+      } catch (e) {
+        notSent = `The notify adapter refused: ${e.message}`;
+      }
+    }
+  }
+  if (o.json)
+    io.out(JSON.stringify({ ...d, ...sent ? { sent } : {}, ...notSent ? { notSent } : {} }, null, 2));
+  else {
+    io.out(d.title);
+    for (const l of d.lines)
+      io.out(l);
+    if (sent)
+      io.out(`Sent to ${sent.channel} (${sent.id}).`);
+    if (notSent)
+      io.err(notSent);
+  }
+  return o.send && !sent ? 1 : 0;
+}
+
+export {
+  buildDigest,
+  digestCommand
+};

package/dist/chunk-7ZUIMTOU.js

@@ -0,0 +1,108 @@
+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 {
+  ConformError,
+  conformChange,
+  conformanceOf
+} from "./chunk-CEXSU4S6.js";
+import "./chunk-2ANOROX3.js";
+import "./chunk-65NYPGRC.js";
+import "./chunk-OT2O76OS.js";
+import "./chunk-IPKHE5D6.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-TV45EUGM.js";
+
+// packages/cli/dist/change-conform.js
+var CITE = (c) => `${c.repo ? `${c.repo}:` : ""}${c.path}${c.line ? `:${c.line}` : ""}`;
+var LABEL = {
+  found: "found",
+  missing: "MISSING",
+  "still-there": "STILL THERE",
+  unexpected: "NOT IN THE DESIGN"
+};
+function print(results, io) {
+  for (const r of results) {
+    const n = r.counts;
+    io.out(`${r.repo} at ${r.ref} (${r.commit.slice(0, 12)}, from ${r.base.slice(0, 12)})${r.task ? `, task ${r.task}` : ""}: ${n.found} found, ${n.missing} missing, ${n.stillThere} still there, ${n.unexpected} not in the design.`);
+    for (const i of r.items)
+      io.out(`  ${LABEL[i.status]}  ${i.what}  ${i.at.map(CITE).join(", ")}${i.finding && i.finding.state !== "open" ? ` (${i.finding.state})` : ""}`);
+    if (r.unchecked.length) {
+      io.out("  Not checked by a scan (a person or a test checks these):");
+      for (const u of r.unchecked)
+        io.out(`    ${u.flow}${u.item ? ` item ${u.item}` : " trigger"} (${u.kind}): ${u.why}`);
+    }
+    for (const p of r.problems)
+      io.err(`${r.repo}: ${p}`);
+  }
+}
+async function changeConformCommand(root, change, o, io) {
+  if (o.latest) {
+    const v = await conformanceOf(root, change);
+    if (!v) {
+      io.err(`There is no change ${change}.`);
+      return 2;
+    }
+    if (o.json) {
+      io.out(JSON.stringify(v, null, 2));
+      return 0;
+    }
+    for (const p of v.problems)
+      io.err(p);
+    if (!v.results.length)
+      io.out(v.flows ? `${change} hasn't been checked against its target flows yet: atticus change conform ${change}.` : `${change} has no target flows yet, so there is nothing to check the code against.`);
+    print(v.results, io);
+    return 0;
+  }
+  try {
+    const run = await conformChange(root, change, {
+      ...o.repo ? { repo: o.repo } : {},
+      ...o.ref ? { ref: o.ref } : {},
+      ...o.task ? { task: o.task } : {}
+    });
+    const bad = run.results.some((r) => r.counts.missing + r.counts.stillThere + r.counts.unexpected > 0);
+    if (o.json) {
+      io.out(JSON.stringify(await conformanceOf(root, change), null, 2));
+      return run.results.length && !bad ? 0 : 1;
+    }
+    for (const p of run.problems)
+      io.err(p);
+    if (!run.flows) {
+      io.err(`${change} has no target flows yet, so there is nothing to check the code against: the architecture stage writes them (atticus change architecture ${change}).`);
+      return 1;
+    }
+    if (!run.results.length)
+      return 1;
+    print(run.results, io);
+    io.out(bad ? `The findings are on the conform gate${run.round ? ` (round ${run.round})` : ""}: atticus findings ${change} lists them; dismiss one with atticus finding ${change} <id> not-relevant --reason "...".` : "The code has everything its target flows add, and nothing they don't name.");
+    return bad ? 1 : 0;
+  } catch (e) {
+    if (e instanceof ConformError) {
+      io.err(e.message);
+      return 2;
+    }
+    throw e;
+  }
+}
+export {
+  changeConformCommand
+};

package/dist/chunk-A3GY6SOA.js

@@ -0,0 +1,95 @@
+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 {
+  askKnowledgeConflicts,
+  knowledgeAppliesMarkdown,
+  readKnowledgeApplies,
+  setKnowledgeStatus
+} from "./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 {
+  conflictLine
+} from "./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 {
+  changesRelOf
+} from "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/knowledge-applies-commands.js
+async function changeKnowledge(root, change, o, io) {
+  const said = [];
+  try {
+    for (const [id, status] of [
+      [o.confirm, "confirmed"],
+      [o.exclude, "excluded"]
+    ]) {
+      if (!id)
+        continue;
+      const d = await setKnowledgeStatus(root, change, id, status);
+      const i = d.items.find((x) => x.id === id);
+      const what = `${id} (${i.kind}${i.title && i.title !== id ? `, ${i.title}` : ""})`;
+      said.push(status === "confirmed" ? `Confirmed ${what}: every later stage that takes it selects it.` : `Excluded ${what}: every later stage leaves it out.`);
+    }
+  } catch (e) {
+    io.err(e.message);
+    return 2;
+  }
+  if (said.length) {
+    if (o.json)
+      io.out(JSON.stringify(await readKnowledgeApplies(root, change), null, 2));
+    else
+      for (const l of said)
+        io.out(l);
+    if (!o.json)
+      io.out(`Written to ${changesRelOf(root)}/${change}/knowledge.yaml; commit it with the change's files.`);
+    return 0;
+  }
+  const doc = await readKnowledgeApplies(root, change);
+  if (!doc) {
+    io.err(`${change} has no knowledge list yet: its feature stage writes ${changesRelOf(root)}/${change}/knowledge.yaml with the patterns, standards, decisions, processes and requests and the wiki and document sections it picks, and every later stage adds what it picks (atticus change feature ${change}).`);
+    return 2;
+  }
+  const command = `atticus change knowledge ${change}`;
+  const asked = await askKnowledgeConflicts(root, change, {
+    command,
+    rerun: command,
+    at: (o.now ?? /* @__PURE__ */ new Date()).toISOString()
+  });
+  if (o.json)
+    io.out(JSON.stringify({ ...doc, conflicts: asked.touching }, null, 2));
+  else {
+    for (const l of knowledgeAppliesMarkdown(doc).trimEnd().split("\n"))
+      io.out(l);
+    if (asked.touching.length) {
+      io.out("");
+      io.out("### Pages that disagree");
+      io.out("");
+      for (const v of asked.touching)
+        io.out(`- ${conflictLine(v)}`);
+      for (const q of asked.raised)
+        io.out(`Asked a person which page applies: question ${q.id} (atticus questions answer ${q.id} --option <n>).`);
+    }
+    io.out(`Confirm or exclude an item: atticus change knowledge ${change} --confirm <id> (or --exclude <id>); an excluded one stays out of later stages.`);
+  }
+  return 0;
+}
+export {
+  changeKnowledge
+};