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

package/dist/chunk-XTVDAHH2.js

@@ -0,0 +1,203 @@
+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 {
+  buildSite,
+  catalogRecords,
+  openChanges
+} from "./chunk-DPHCFZ7W.js";
+import {
+  doctorChecks
+} from "./chunk-FV5YFR6I.js";
+import {
+  readProbes,
+  whatRunsWhere
+} from "./chunk-LK44ULGI.js";
+import {
+  baseClonePath,
+  loadRepos
+} from "./chunk-PGKHJYOB.js";
+import {
+  CatalogBaseline,
+  DEFAULT_RUNTIME,
+  WORKSPACE_SCHEMA_VERSION,
+  catalogDirOf,
+  inputsDirOf,
+  loadOrgPack,
+  orgPackDirOf,
+  require_dist
+} from "./chunk-577AJVRS.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/baseline-commands.js
+var import_yaml = __toESM(require_dist(), 1);
+import { readdir, readFile, stat, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+var BASELINE_FILE = "baseline.yaml";
+async function readBaseline(root) {
+  try {
+    const r = CatalogBaseline.safeParse((0, import_yaml.parse)(await readFile(join(catalogDirOf(root), BASELINE_FILE), "utf8")));
+    return r.success ? r.data : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function countFiles(dir) {
+  try {
+    const all = await readdir(dir, { recursive: true, withFileTypes: true });
+    return all.filter((e) => e.isFile()).length;
+  } catch {
+    return 0;
+  }
+}
+async function setupSteps(root, o = {}) {
+  const clonedOf = async (repos2) => (await Promise.all(repos2.map((r) => stat(join(baseClonePath(root, r.id), ".git")).then(() => true, () => false)))).filter(Boolean).length;
+  const [doctor, op, repos, records, inputs, baseline, probes] = await Promise.all([
+    o.doctor ?? doctorChecks(root),
+    loadOrgPack(orgPackDirOf(root)),
+    loadRepos(root).catch(() => []),
+    catalogRecords(root),
+    countFiles(inputsDirOf(root)),
+    readBaseline(root),
+    readProbes(root).then((p) => p.results)
+  ]);
+  const failing = doctor.filter((c) => c.status === "fail");
+  const cloned = await clonedOf(repos);
+  const generated = records.filter((r) => r.evidence.some((e) => e.source !== "manual")).length;
+  const wikis = op.sources.wikis.length;
+  const steps = [
+    {
+      id: "machine",
+      label: "This machine has what Atticus needs",
+      done: failing.length === 0,
+      detail: failing.length ? `to fix: ${failing.map((c) => c.label).join(", ")}` : `${doctor.filter((c) => c.status === "warn").length} to look at`,
+      fix: failing.length ? `Run atticus doctor: ${failing.map((c) => c.fix ?? c.label).join(" ")}` : "Run atticus doctor for the details."
+    },
+    {
+      id: "org-pack",
+      label: "The org pack's files are valid",
+      done: op.problems.length === 0,
+      detail: op.problems.length ? `${op.problems.length} problem${op.problems.length === 1 ? "" : "s"}` : "no problems in its files",
+      fix: "Run atticus orgpack validate and fix each problem it names (each says the file and field)."
+    },
+    {
+      // A new metarepo's org pack is valid as atticus init wrote it, but nobody owns it yet.
+      id: "org-pack-owner",
+      label: "The org pack has an owner",
+      done: !!op.pack?.owner && op.pack.owner !== "unassigned",
+      detail: op.pack?.owner && op.pack.owner !== "unassigned" ? op.pack.owner : "unassigned",
+      fix: "Set owner in org-pack/pack.yaml to the person who looks after the org pack (normally the platform lead), and commit it through a pull request."
+    },
+    {
+      // ADR 0121 item 6: how AI runs here is a choice, not the default left by accident.
+      id: "ai",
+      label: "Choose how AI runs here",
+      // runtime.yaml's version alone (1 from an older init, ADR 0121 addendum) isn't a choice.
+      done: JSON.stringify({ ...op.runtime, schemaVersion: DEFAULT_RUNTIME.schemaVersion }) !== JSON.stringify(DEFAULT_RUNTIME),
+      detail: whatRunsWhere(op.runtime, { probes }),
+      fix: "Choose the assistants, the modes and the model provider on Set up \u203A AI in the app (or in org-pack/runtime.yaml), and commit it through a pull request. As atticus init wrote it, steps are handed to Copilot, which needs nothing more.",
+      optional: true
+    },
+    {
+      id: "repos",
+      label: "Repos are listed",
+      done: repos.length > 0,
+      detail: `${repos.length} repo${repos.length === 1 ? "" : "s"} in the manifests`,
+      fix: "Run atticus repos discover <folder> (or --org <org>) and add what it proposes to repos.manifest.yaml."
+    },
+    {
+      id: "clones",
+      label: "Repos are cloned here",
+      done: repos.length > 0 && cloned === repos.length,
+      detail: `${cloned} of ${repos.length} cloned`,
+      fix: "Run atticus workspace sync (or Sync repos on the Scans screen); it clones what's missing."
+    },
+    {
+      // ADR 0124: your assistant reads each repo and writes its facts; Atticus checks every one
+      // against its line and puts them in the catalog. The id stays: the app keys on it.
+      id: "scan",
+      label: "Every repo is read and verified",
+      done: generated > 0,
+      detail: `${records.length} record${records.length === 1 ? "" : "s"} in the catalog`,
+      fix: "Read each repo: /atticus-map <repo> in your assistant (or atticus map <repo>), then atticus verify <repo> --write. Verify checks every fact against the line it cites and runs no model."
+    },
+    {
+      id: "knowledge",
+      label: "Existing knowledge is added",
+      done: inputs > 0 || wikis > 0,
+      detail: `${inputs} file${inputs === 1 ? "" : "s"} in inputs/, ${wikis} wiki source${wikis === 1 ? "" : "s"}`,
+      fix: "Drop diagrams, partner specs and exports into inputs/ (atticus intake add <files>), and add wikis to sources.yaml (atticus sources add).",
+      optional: true
+    },
+    {
+      id: "baseline",
+      label: "The catalog is accepted",
+      done: !!baseline,
+      detail: baseline ? `accepted by ${baseline.acceptedBy} on ${baseline.acceptedAt.slice(0, 10)}` : "not yet",
+      fix: "Walk the ecosystem map with the architect, then accept it: atticus baseline (or Accept the catalog on Home), and commit catalog/baseline.yaml through a pull request."
+    }
+  ];
+  return { steps, baselined: !!baseline };
+}
+async function setupCommand(root, o, io) {
+  const s = await setupSteps(root);
+  const open = s.steps.filter((x) => !x.done && !x.optional);
+  if (o.json)
+    io.out(JSON.stringify(s, null, 2));
+  else {
+    for (const x of s.steps) {
+      io.out(`${x.done ? "[x]" : "[ ]"} ${x.label}: ${x.detail}${x.optional ? " (optional)" : ""}`);
+      if (!x.done && x.fix)
+        io.out(`    ${x.fix}`);
+    }
+    io.out(open.length ? `${open.length} step${open.length === 1 ? "" : "s"} to go.` : "Setup is done: the catalog is accepted.");
+  }
+  return open.length ? 1 : 0;
+}
+async function baselineCommand(root, o, io) {
+  if (!o.by) {
+    io.err("Usage: atticus baseline [--by <you>] [--note <text>] [--site <dir>]");
+    return 2;
+  }
+  const records = await catalogRecords(root, io);
+  if (records.length === 0) {
+    io.err("The catalog is empty: read the repos first (atticus map <repo>, then atticus verify <repo> --write), then walk the map and accept it.");
+    return 1;
+  }
+  const kinds = {};
+  for (const r of records)
+    kinds[r.kind] = (kinds[r.kind] ?? 0) + 1;
+  const systems = records.filter((r) => r.kind === "System").map((r) => r.id).sort();
+  const b = CatalogBaseline.parse({
+    schemaVersion: WORKSPACE_SCHEMA_VERSION,
+    acceptedBy: o.by,
+    acceptedAt: o.now ?? (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z"),
+    kinds: Object.fromEntries(Object.entries(kinds).sort(([a], [b2]) => a.localeCompare(b2))),
+    systems,
+    ...o.note ? { note: o.note } : {}
+  });
+  await writeFile(join(catalogDirOf(root), BASELINE_FILE), (0, import_yaml.stringify)(b), "utf8");
+  io.out(`Accepted the catalog as the baseline as ${o.by}: ${records.length} records in ${Object.keys(kinds).length} kinds, ${systems.length} systems. Wrote catalog/${BASELINE_FILE}; commit it with the catalog and open a pull request, whose merge makes it the baseline on main.`);
+  if (o.site) {
+    const dir = resolve(o.site);
+    const s = await buildSite(records, dir, {
+      title: "Catalog",
+      builtAt: b.acceptedAt.slice(0, 10),
+      changes: await openChanges(root)
+    });
+    io.out(`Wrote the read-only catalog site to ${dir} (${s.systems.length} systems).`);
+  }
+  return 0;
+}
+
+export {
+  BASELINE_FILE,
+  readBaseline,
+  setupSteps,
+  setupCommand,
+  baselineCommand
+};

package/dist/chunk-XZRON6IV.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-TV45EUGM.js";
+
+// packages/cli/dist/waiting-commands.js
+var CLOSED = /* @__PURE__ */ new Set(["released", "archived", "closed"]);
+async function readWaiting(run, o) {
+  const problems = [];
+  const json = async (argv, fallback) => {
+    const r = await run(argv);
+    try {
+      return JSON.parse(r.out);
+    } catch {
+      problems.push(`atticus ${argv.join(" ")}: ${r.err.trim().split("\n")[0] || "no answer"}`);
+      return fallback;
+    }
+  };
+  const questions = (await json(["questions", "list", "--state", "open", "--json"], {})).questions ?? [];
+  const needs = (await json(["needs", "--all", "--json"], [])).filter((n) => (n.status ?? "open") === "open");
+  const steps = (await json(["todo", "--json"], [])).filter((s) => (s.state ?? "open") === "open");
+  const changes = (await json(["change", "list", "--json"], [])).filter((c) => !CLOSED.has(c.state));
+  const findings = /* @__PURE__ */ new Map();
+  for (const c of changes)
+    findings.set(c.id, (await json(["findings", c.id, "--json"], [])).filter((f) => (f.state ?? "open") === "open"));
+  const unverified = await json(["knowledge", "list", "--unverified", "--json"], []);
+  const words = o.filter?.trim().toLowerCase();
+  const hit = (...fields) => !words || fields.some((f) => f !== void 0 && f.toLowerCase().includes(words));
+  const byChange = [];
+  for (const c of changes) {
+    const whole = hit(c.id, c.title);
+    const w = {
+      change: c.id,
+      title: c.title,
+      state: c.state,
+      needs: needs.filter((n) => n.change === c.id && (whole || hit(n.item, n.title, n.kind, n.handledBy))),
+      findings: (findings.get(c.id) ?? []).filter((f) => whole || hit(f.id, f.summary, f.severity)),
+      manualSteps: steps.filter((s) => s.change === c.id && (whole || hit(s.id, s.title, s.where)))
+    };
+    if (w.needs.length + w.findings.length + w.manualSteps.length)
+      byChange.push(w);
+  }
+  const blocking = (w) => w.findings.some((f) => f.severity === "blocking");
+  byChange.sort((a, b) => Number(blocking(b)) - Number(blocking(a)) || a.title.localeCompare(b.title));
+  const known = new Set(changes.map((c) => c.id));
+  const other = {
+    questions: questions.filter((q) => hit(q.id, q.repo, q.question)),
+    manualSteps: steps.filter((s) => (!s.change || !known.has(s.change)) && hit(s.id, s.title, s.where, s.change)),
+    knowledgeToVerify: words ? 0 : unverified.length
+  };
+  const sum = (f) => byChange.reduce((n, w) => n + f(w), 0);
+  return {
+    changes: byChange,
+    other,
+    counts: {
+      questions: other.questions.length,
+      needs: sum((w) => w.needs.length),
+      manualSteps: sum((w) => w.manualSteps.length) + other.manualSteps.length,
+      findings: sum((w) => w.findings.length),
+      knowledgeToVerify: other.knowledgeToVerify
+    },
+    problems
+  };
+}
+var plural = (n, w) => `${n} ${w}${n === 1 ? "" : "s"}`;
+var stepId = (s) => s.change ? `${s.change}/${s.id}` : s.id;
+function byChangeLines(w) {
+  const out = [];
+  for (const c of w.changes) {
+    const parts = [
+      c.needs.length && plural(c.needs.length, "need"),
+      c.findings.length && plural(c.findings.length, "finding"),
+      c.manualSteps.length && plural(c.manualSteps.length, "manual step")
+    ].filter(Boolean);
+    out.push(`${c.title} (${c.change}): ${parts.join(", ")}`);
+    for (const n of c.needs)
+      out.push(`  need     ${n.item}: ${n.title}`);
+    for (const f of c.findings)
+      out.push(`  finding  ${f.id} (${f.severity}): ${f.summary}`);
+    for (const s of c.manualSteps)
+      out.push(`  step     ${stepId(s)}: ${s.title}`);
+  }
+  const o = w.other;
+  if (o.questions.length || o.manualSteps.length || o.knowledgeToVerify) {
+    out.push("Not tied to a change:");
+    for (const q of o.questions)
+      out.push(`  question ${q.id} (${q.repo}): ${q.question}`);
+    for (const s of o.manualSteps)
+      out.push(`  step     ${stepId(s)}: ${s.title}`);
+    if (o.knowledgeToVerify)
+      out.push(`  ${plural(o.knowledgeToVerify, "knowledge item")} no one has verified: atticus knowledge list --unverified`);
+  }
+  return out;
+}
+function byKindLines(w) {
+  const out = [];
+  const group = (title, lines) => {
+    if (lines.length)
+      out.push(`${title} (${lines.length})`, ...lines.map((l) => `  ${l}`));
+  };
+  group("Questions", w.other.questions.map((q) => `${q.id} (${q.repo}): ${q.question}`));
+  group("Needs", w.changes.flatMap((c) => c.needs.map((n) => `${n.item} (${c.change}): ${n.title}`)));
+  group("Manual steps", [...w.changes.flatMap((c) => c.manualSteps), ...w.other.manualSteps].map((s) => `${stepId(s)}: ${s.title}`));
+  group("Findings", w.changes.flatMap((c) => c.findings.map((f) => `${f.id} (${c.change}, ${f.severity}): ${f.summary}`)));
+  if (w.other.knowledgeToVerify)
+    out.push(`Knowledge to verify (${w.other.knowledgeToVerify}): atticus knowledge list --unverified`);
+  return out;
+}
+async function waitingCli(o, io, run) {
+  const by = o.by ?? "change";
+  const w = await readWaiting(run, o.filter ? { filter: o.filter } : {});
+  if (o.json) {
+    io.out(JSON.stringify({ by, ...w }, null, 2));
+    return 0;
+  }
+  const lines = by === "kind" ? byKindLines(w) : byChangeLines(w);
+  if (!lines.length)
+    io.out(o.filter ? `Nothing waits on you that matches "${o.filter}".` : "Nothing waits on you.");
+  else
+    for (const l of lines)
+      io.out(l);
+  for (const p of w.problems)
+    io.err(`Couldn't read ${p}`);
+  return 0;
+}
+export {
+  readWaiting,
+  waitingCli
+};