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

package/dist/chunk-RUGXBPWI.js

@@ -0,0 +1,384 @@
+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 {
+  generateTests,
+  matrixCsv,
+  matrixMarkdown,
+  traceMatrix,
+  writeTraceFindings
+} from "./chunk-BTGPE6CR.js";
+import {
+  DriftError,
+  SNIPPET_KINDS,
+  archiveGate,
+  driftExitCode,
+  driftJUnit,
+  driftJson,
+  driftMarkdown,
+  pipelineSnippet,
+  repoDrift
+} from "./chunk-ZQ7SKESZ.js";
+import {
+  table
+} from "./chunk-VOGCSYOI.js";
+import {
+  GlossaryError,
+  aliasDecision,
+  completeGlossaryDefinitions,
+  defineDecision,
+  linkDecision,
+  loadGlossary,
+  resolveTermId,
+  scanGlossary,
+  writeDecisions
+} from "./chunk-J2JAKCIW.js";
+import {
+  createGit
+} from "./chunk-PKBHS4AA.js";
+import {
+  runtimeForCli
+} from "./chunk-P32RUW3B.js";
+
+// packages/cli/dist/quality-commands.js
+import { appendFile, mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+var KNOWN = /* @__PURE__ */ new Set([
+  "TestgenError",
+  "PlannerError",
+  "ChangeError",
+  "ChangeFileError",
+  "GlossaryError",
+  "RuntimeConfigError"
+]);
+function fail(io, e) {
+  if (e instanceof Error && KNOWN.has(e.name)) {
+    io.err(e.message);
+    return e.code === "invalid" ? 2 : 1;
+  }
+  throw e;
+}
+var iso = (d) => d.toISOString().replace(/\.\d{3}Z$/, "Z");
+var lines = (io, text) => {
+  for (const l of text.trimEnd().split("\n"))
+    io.out(l);
+};
+var plural = (n, w) => `${n} ${w}${n === 1 ? "" : "s"}`;
+async function runtimeOf(root, mode, deps) {
+  if (deps.runtime)
+    return deps.runtime;
+  if (!mode && !process.env.ATTICUS_RUNTIME)
+    return void 0;
+  return (await runtimeForCli(root, mode ? { mode } : {})).runtime;
+}
+async function testsGenerate(root, changeId, storyId, o, io, deps = {}) {
+  if (!changeId || !storyId) {
+    io.err("Usage: atticus tests generate <change> <story> [--framework <id>] [--force] [--check] [--mode <mode>] [--json]");
+    return 2;
+  }
+  try {
+    const runtime = await runtimeOf(root, o.mode, deps);
+    const r = await generateTests(root, changeId, storyId, {
+      ...o.framework ? { framework: o.framework } : {},
+      ...o.force ? { force: true } : {},
+      ...o.check ? { check: true } : {},
+      ...o.resume ? { resume: o.resume } : {},
+      ...runtime ? { runtime } : {},
+      now: deps.now?.() ?? /* @__PURE__ */ new Date()
+    });
+    const kept = r.files.filter((f) => f.action === "kept-edited" || f.action === "kept-not-generated");
+    if (o.json) {
+      io.out(JSON.stringify({
+        change: r.change,
+        story: r.story,
+        strategy: r.model.strategy,
+        kinds: r.model.kinds,
+        names: r.names.by,
+        ...r.names.waiting ? { waiting: r.names.waiting } : {},
+        files: r.files,
+        manifest: r.manifest,
+        notes: r.notes,
+        gaps: r.gaps
+      }, null, 2));
+      return kept.length ? 1 : 0;
+    }
+    const count = (a) => r.files.filter((f) => f.action === a).length;
+    const cases = r.model.repos.reduce((n, x) => n + x.cases.length, 0);
+    io.out(`${o.check ? "Would write" : "Generated"} ${plural(cases, "test case")} for ${r.story} in ${plural(r.files.length, "file")}: ${count("created")} new, ${count("updated")} updated, ${count("unchanged")} unchanged${kept.length ? `, ${kept.length} kept` : ""}.`);
+    for (const l of table(["ACTION", "REPO", "FRAMEWORK", "FILE"], r.files.map((f) => [f.action, f.repo || "-", f.generator, f.path])))
+      io.out(l);
+    for (const k of r.model.kinds.filter((x) => !x.generated))
+      io.out(`No ${k.type} tests: ${k.why}`);
+    for (const n of r.notes)
+      io.out(n);
+    for (const g of r.gaps)
+      io.out(`Gap: ${g}`);
+    if (r.names.waiting)
+      io.out(`The test writer is with your assistant (run ${r.names.waiting}); the files use plain names until you run: atticus tests generate ${changeId} ${storyId} --resume ${r.names.waiting}`);
+    if (!o.check)
+      io.out(`Manifest: ${r.manifest}`);
+    return kept.length ? 1 : 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function traceCommand(root, changeId, o, io, deps = {}) {
+  if (!changeId) {
+    io.err("Usage: atticus trace <change> [--json | --csv] [--no-write]");
+    return 2;
+  }
+  try {
+    const m = await traceMatrix(root, changeId, { git: deps.git ?? createGit() });
+    for (const p of m.problems)
+      io.err(p);
+    const w = o.write === false ? void 0 : await writeTraceFindings(root, m, iso(deps.now?.() ?? /* @__PURE__ */ new Date()));
+    if (o.json)
+      io.out(JSON.stringify({ ...m, ...w ? { round: w.round ?? null } : {} }, null, 2));
+    else if (o.csv)
+      lines(io, matrixCsv(m));
+    else {
+      lines(io, matrixMarkdown(m));
+      if (w)
+        io.out(w.unchanged ? `Findings on the trace gate are unchanged (round ${w.round ?? "none"}).` : `Wrote ${plural(w.findings.length, "finding")} to review/trace/${w.round}/.`);
+    }
+    return m.gaps.some((g) => g.kind !== "test-without-requirement") ? 1 : 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function ciDrift(repoDir, o, io, deps = {}) {
+  if (!o.catalog) {
+    io.err("Usage: atticus ci drift [repo-dir] --catalog <metarepo or catalog folder> [--repo <id>] [--json [file]] [--junit <file>] [--summary <file>] [--warn-only]");
+    return 2;
+  }
+  try {
+    const r = await repoDrift({
+      repoDir,
+      catalog: o.catalog,
+      ...o.repo ? { repo: o.repo } : {},
+      ...o.warnOnly ? { warnOnly: true } : {},
+      ...deps.commit ? { commit: deps.commit } : {},
+      ...deps.git ? { git: deps.git } : {}
+    });
+    const put = async (file, text) => {
+      await mkdir(dirname(file), { recursive: true });
+      await writeFile(file, text, "utf8");
+    };
+    if (typeof o.json === "string")
+      await put(o.json, driftJson(r));
+    if (o.junit)
+      await put(o.junit, driftJUnit(r));
+    if (o.summary) {
+      await mkdir(dirname(o.summary), { recursive: true });
+      await appendFile(o.summary, driftMarkdown(r), "utf8");
+    }
+    if (o.json === true)
+      io.out(driftJson(r).trimEnd());
+    else
+      lines(io, driftMarkdown(r));
+    return driftExitCode(r);
+  } catch (e) {
+    if (e instanceof DriftError) {
+      io.err(e.message);
+      return 2;
+    }
+    throw e;
+  }
+}
+async function ciSnippet(kind, io, o = {}) {
+  const s = kind ? pipelineSnippet(kind) : void 0;
+  if (!s) {
+    io.err(`Usage: atticus ci snippet <${SNIPPET_KINDS.join("|")}> [--write <repo-dir>]`);
+    return 2;
+  }
+  if (o.write) {
+    const file = join(o.write, ...s.path.split("/"));
+    await mkdir(dirname(file), { recursive: true });
+    await writeFile(file, s.content, "utf8");
+    io.out(`Wrote ${s.path}. Set the variables its first lines name, then commit it.`);
+    return 0;
+  }
+  lines(io, s.content);
+  return 0;
+}
+async function ciArchiveGate(root, changeId, o, io, deps = {}) {
+  if (!changeId) {
+    io.err("Usage: atticus ci archive-gate <change> [--drift <report.json>...] [--json]");
+    return 2;
+  }
+  let r;
+  try {
+    r = await archiveGate(root, changeId, {
+      ...o.drift?.length ? { driftReports: o.drift } : {},
+      ...deps.commit ? { commit: deps.commit } : {}
+    });
+  } catch (e) {
+    if (e instanceof Error && e.name === "ChangeFileError") {
+      io.err(e.message);
+      return 2;
+    }
+    throw e;
+  }
+  if (o.json)
+    io.out(JSON.stringify(r, null, 2));
+  else {
+    io.out(r.pass ? `${changeId} may be archived: no blockers, its release PRs merged and built, and the catalog says what shipped.` : `${changeId} can't be archived yet (${plural(r.blockers.length, "blocker")}):`);
+    for (const b of r.blockers)
+      io.out(`- ${b.message}`);
+    for (const n of r.notes)
+      io.out(n);
+  }
+  return r.pass ? 0 : 1;
+}
+var short = (s, n = 70) => s.length <= n ? s : `${s.slice(0, n - 3)}...`;
+var sourceOf = (flags, confidence) => confidence === "asserted" ? "person" : flags?.includes("ai-proposed") ? "ai" : flags?.includes("undefined") ? "code" : "wiki";
+async function glossaryList(root, o, io) {
+  const g = await loadGlossary(root);
+  for (const p of g.problems)
+    io.err(p);
+  if (o.json) {
+    io.out(JSON.stringify({
+      terms: g.terms,
+      conflicts: g.build.conflicts,
+      hints: g.build.hints,
+      synonyms: Object.fromEntries(g.build.entries.filter((e) => e.aliases.length).map((e) => [e.id, e.aliases]))
+    }, null, 2));
+    return 0;
+  }
+  if (!g.terms.length) {
+    io.out("The glossary is empty: no wiki page defines a term and the catalog has no domain words yet.");
+    return 0;
+  }
+  for (const l of table(["TERM", "ID", "FROM", "FLAGS", "DEFINITION"], g.terms.map((t) => [
+    t.term,
+    t.id,
+    sourceOf(t.flags, t.confidence),
+    (t.flags ?? []).join(","),
+    short(t.definition)
+  ])))
+    io.out(l);
+  io.out(`${plural(g.terms.length, "term")}, ${plural(g.build.conflicts.filter((c) => !c.resolved).length, "conflict")}.`);
+  return 0;
+}
+async function glossaryScan(root, o, io, deps = {}) {
+  try {
+    const runtime = await runtimeOf(root, o.mode, deps);
+    const r = await scanGlossary(root, {
+      ...runtime ? { runtime } : {},
+      ...deps.now ? { now: deps.now() } : {}
+    });
+    if (o.json) {
+      for (const p of r.problems)
+        io.err(p);
+      io.out(JSON.stringify({
+        terms: r.terms.length,
+        written: r.written,
+        removed: r.removed,
+        conflicts: r.build.conflicts,
+        hints: r.build.hints,
+        ...r.propose ? { proposals: r.propose.proposals.length, discarded: r.propose.discarded } : {}
+      }, null, 2));
+      return 0;
+    }
+    printGlossaryScan(r, io);
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+function printGlossaryScan(r, io) {
+  for (const p of r.problems)
+    io.err(p);
+  const open = r.build.conflicts.filter((c) => !c.resolved);
+  io.out(`The glossary has ${plural(r.terms.length, "term")}; ${plural(r.written.length, "file")} written and ${plural(r.removed.length, "file")} removed in catalog/generated.`);
+  if (r.propose)
+    io.out(r.propose.waiting ? `The glossary definer is with your assistant (run ${r.propose.waiting}). When it is done, run: atticus handoff done ${r.propose.waiting}` : `The glossary definer proposed ${plural(r.propose.proposals.length, "definition")} (kept inferred until a person defines the term).`);
+  for (const d of r.propose?.discarded ?? [])
+    if (d.term && !r.propose?.waiting)
+      io.err(`Discarded ${d.term}: ${d.reason}`);
+  for (const c of open)
+    io.out(`Conflict: ${c.message}`);
+  for (const h of r.build.hints)
+    io.out(`Naming: ${h.message}`);
+}
+async function completeGlossaryScan(root, run, io, deps = {}) {
+  try {
+    const r = await completeGlossaryDefinitions(root, run, deps.now ? { now: deps.now } : {});
+    printGlossaryScan(r, io);
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function decide(root, io, make, said) {
+  try {
+    const g = await loadGlossary(root);
+    const ds = make(g);
+    const files = await writeDecisions(join(g.catalogDir, "curated"), ds);
+    await scanGlossary(root);
+    io.out(`Wrote ${files.map((f) => `catalog/curated/${f}`).join(" and ")}: ${said}. Commit it so every scan keeps it.`);
+    return 0;
+  } catch (e) {
+    if (e instanceof GlossaryError) {
+      io.err(e.message);
+      return e.code === "invalid" ? 2 : 1;
+    }
+    throw e;
+  }
+}
+async function glossaryDefine(root, term, definition, o, io) {
+  if (!term || !definition || !o.by) {
+    io.err('Usage: atticus glossary define <term> "<definition>" [--by <handle>] [--owner <team>]');
+    return 2;
+  }
+  return decide(root, io, (g) => {
+    const existing = g.terms.find((t) => t.id === resolveTermId(term));
+    return [
+      defineDecision(term, definition, {
+        by: o.by,
+        ...o.owner ? { owner: o.owner } : {},
+        ...existing ? { existing } : {}
+      })
+    ];
+  }, `${resolveTermId(term)} is defined and asserted`);
+}
+async function glossaryLink(root, term, recordId, o, io) {
+  if (!term || !recordId || !o.by) {
+    io.err("Usage: atticus glossary link <term> <record-id | schema#field> [--by <handle>]");
+    return 2;
+  }
+  return decide(root, io, (g) => {
+    const id = resolveTermId(term);
+    const t = g.terms.find((x) => x.id === id);
+    if (!t)
+      throw new GlossaryError("not-found", `There is no term ${id}. Define it first: atticus glossary define`);
+    return [linkDecision(t, recordId, g.base, { by: o.by })];
+  }, `${recordId} is linked to ${resolveTermId(term)}`);
+}
+async function glossaryAlias(root, term, names, o, io) {
+  if (!term || !names.length || !o.by) {
+    io.err('Usage: atticus glossary alias <term> "<other name>"... [--by <handle>]');
+    return 2;
+  }
+  return decide(root, io, (g) => {
+    const id = resolveTermId(term);
+    const before = g.build.entries.find((e) => e.id === id)?.aliases ?? [];
+    return [aliasDecision(id, [...before, ...names], { by: o.by })];
+  }, `${names.join(", ")} ${names.length === 1 ? "is another name" : "are other names"} for ${resolveTermId(term)}`);
+}
+
+export {
+  testsGenerate,
+  traceCommand,
+  ciDrift,
+  ciSnippet,
+  ciArchiveGate,
+  glossaryList,
+  glossaryScan,
+  completeGlossaryScan,
+  glossaryDefine,
+  glossaryLink,
+  glossaryAlias
+};

package/dist/{chunk-CPA6HPVR.js → chunk-RXPJMEOW.js}

@@ -7,10 +7,10 @@ import {
   cliMarkdown,
   gradeDialect,
   kindsMarkdown
-} from "./chunk-KEM4SDDP.js";
+} from "./chunk-O7FDLW7L.js";
 import {
   generateTests
-} from "./chunk-2ANOROX3.js";
+} from "./chunk-BTGPE6CR.js";
 import {
   DEFAULT_DONE,
   DESIGN_FORMAT,
@@ -33,19 +33,19 @@ import {
   storySteps,
   unfence,
   writesField
-} from "./chunk-CKSITVS4.js";
+} from "./chunk-R7NYHMUU.js";
 import {
   DesignScreen
-} from "./chunk-L6SGQIR3.js";
+} from "./chunk-IVBOQAGB.js";
 import {
   BUILT_IN_CHECKS,
   runCritic
-} from "./chunk-3HI6Z55Y.js";
+} from "./chunk-S4PMJU6H.js";
 import {
   buildGlossary,
   proposeDefinitions,
   undefinedCodeTerms
-} from "./chunk-27NKUS3X.js";
+} from "./chunk-J2JAKCIW.js";
 import {
   askKnowledge,
   checkQuote,
@@ -60,16 +60,16 @@ import {
   termsOf,
   writeKnowledge,
   writeSnapshots
-} from "./chunk-L24C55VN.js";
+} from "./chunk-745DAZ4L.js";
 import {
   writeChangeRepos
-} from "./chunk-EFHQ3TWP.js";
+} from "./chunk-PKBHS4AA.js";
 import {
   MockRuntime,
   ReplayRuntime,
   RuntimeError,
   buildContextPack
-} from "./chunk-CNUKCS2T.js";
+} from "./chunk-P32RUW3B.js";
 import {
   AgentDefinition,
   KNOWLEDGE_KINDS,
@@ -81,10 +81,12 @@ import {
   parseRecord,
   projectFacts,
   recordPath,
-  require_dist,
   serializeRecord,
   stateDirOf
-} from "./chunk-S2A7YC3Q.js";
+} from "./chunk-Q2TECDIT.js";
+import {
+  require_dist
+} from "./chunk-BQGDB6ZL.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";
@@ -1592,7 +1594,11 @@ function scoreFacts(ref, facts) {
     deploy: 0,
     config: 0,
     framework: 0,
-    flow: 0
+    flow: 0,
+    // ADR 0163: the organisation's terms the repo writes.
+    term: 0,
+    // ADR 0180: what a component is.
+    component: 0
   };
   for (const f of facts)
     byKind[f.kind]++;