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

package/dist/chunk-2C5B464C.js

@@ -0,0 +1,106 @@
+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 {
+  changeSteps,
+  readNextState
+} from "./chunk-PUKEZ37F.js";
+import "./chunk-XJNDSYGO.js";
+import "./chunk-2MD7TXSG.js";
+import "./chunk-XUPVB7TL.js";
+import "./chunk-CMV7TGU6.js";
+import "./chunk-3G4YI4ZU.js";
+import "./chunk-RCU3MPY2.js";
+import "./chunk-V5PKHHQQ.js";
+import "./chunk-VPTTCYOC.js";
+import "./chunk-L6SGQIR3.js";
+import "./chunk-7UFQZXZA.js";
+import {
+  changeReport
+} from "./chunk-56YQ6ROQ.js";
+import "./chunk-4AK7IBVP.js";
+import "./chunk-7JUKDRSZ.js";
+import "./chunk-OLWFG75W.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 {
+  readChangeRepos
+} from "./chunk-KJPMEAI4.js";
+import "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import {
+  changesDirOf,
+  listQuestions,
+  require_dist
+} from "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/cockpit.js
+var import_yaml = __toESM(require_dist(), 1);
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+var STAGES = ["feature", "architecture", "stories"];
+async function stageProgress(dir, stage, open) {
+  const text = await readFile(join(dir, "stage", `${stage}.yaml`), "utf8").catch(() => void 0);
+  if (!text)
+    return { stage, state: "not-started", drafts: 0, rounds: 0, openQuestions: 0, asked: [] };
+  const y = (0, import_yaml.parse)(text) ?? {};
+  const asked = Array.isArray(y.questions) ? y.questions.filter((q) => typeof q === "string") : [];
+  return {
+    stage,
+    state: typeof y.state === "string" ? y.state : "unknown",
+    drafts: typeof y.iteration === "number" ? y.iteration : 0,
+    rounds: Array.isArray(y.critic) ? y.critic.length : 0,
+    openQuestions: asked.filter((q) => open.has(q)).length,
+    /** The open questions it raised. */
+    asked: asked.filter((q) => open.has(q))
+  };
+}
+async function cockpit(root, id) {
+  const report = await changeReport(root, id);
+  const dir = join(changesDirOf(root), id);
+  const { questions } = await listQuestions(root, { state: "open" }).catch(() => ({
+    questions: []
+  }));
+  const open = new Set(questions.map((q) => q.id));
+  const stages = [];
+  for (const s of STAGES)
+    stages.push(await stageProgress(dir, s, open));
+  const ofChange = /* @__PURE__ */ new Set([
+    ...questions.filter((q) => q.repo === id).map((q) => q.id),
+    ...stages.flatMap((s) => s.asked)
+  ]);
+  const state = (await readNextState(root)).changes.find((c) => c.id === id);
+  const next = state ? changeSteps(state)[0] : void 0;
+  const repos = await readChangeRepos(root, id).catch(() => void 0);
+  return {
+    id,
+    state: report.state,
+    ...next ? { next } : {},
+    nextStep: report.nextStep,
+    reasons: report.reasons,
+    risk: { level: report.risk.level, score: report.risk.score },
+    ...report.progress ? { work: report.progress.summary } : {},
+    stages: stages.map(({ asked: _asked, ...rest }) => rest),
+    openQuestions: ofChange.size,
+    repos: (repos?.repos ?? []).map((r) => ({
+      id: r.id,
+      branch: r.branch,
+      base: r.base,
+      ...r.pr?.url ? { pr: r.pr.url } : {}
+    }))
+  };
+}
+export {
+  STAGES,
+  cockpit
+};

package/dist/chunk-2LLFKP7C.js

@@ -0,0 +1,53 @@
+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 {
+  ciArchiveGate,
+  ciDrift,
+  ciSnippet,
+  completeGlossaryScan,
+  glossaryAlias,
+  glossaryDefine,
+  glossaryLink,
+  glossaryList,
+  glossaryScan,
+  testsGenerate,
+  traceCommand
+} from "./chunk-ZJSP24X4.js";
+import "./chunk-6SCVQZX5.js";
+import "./chunk-65NYPGRC.js";
+import "./chunk-VOGCSYOI.js";
+import "./chunk-VPTTCYOC.js";
+import "./chunk-L6SGQIR3.js";
+import "./chunk-7UFQZXZA.js";
+import "./chunk-56YQ6ROQ.js";
+import "./chunk-4AK7IBVP.js";
+import "./chunk-7JUKDRSZ.js";
+import "./chunk-OLWFG75W.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-KJPMEAI4.js";
+import "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+export {
+  ciArchiveGate,
+  ciDrift,
+  ciSnippet,
+  completeGlossaryScan,
+  glossaryAlias,
+  glossaryDefine,
+  glossaryLink,
+  glossaryList,
+  glossaryScan,
+  testsGenerate,
+  traceCommand
+};

package/dist/chunk-2MD7TXSG.js

@@ -0,0 +1,166 @@
+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 {
+  readCatalog
+} from "./chunk-OLWFG75W.js";
+import {
+  scopeWords
+} from "./chunk-L24C55VN.js";
+import {
+  baseClonePath,
+  loadManifest
+} from "./chunk-KJPMEAI4.js";
+import {
+  Sources,
+  catalogDirOf,
+  orgPackDirOf,
+  require_dist
+} from "./chunk-S2A7YC3Q.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/ui-api-onboarding.js
+var import_yaml = __toESM(require_dist(), 1);
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+var exists = (p) => stat(p).then(() => true, () => false);
+var firstLine = (e) => String(e.message ?? e).split("\n")[0];
+async function onboardingView(root) {
+  const rel = (p) => relative(root, p).split(sep).join("/");
+  const orgPack = orgPackDirOf(root);
+  const problems = [];
+  const manifests = [];
+  const listed = [];
+  const profiles = join(orgPack, "profiles");
+  const names = await readdir(profiles, { withFileTypes: true }).then((d) => d.filter((x) => x.isDirectory()).map((x) => x.name).sort(), () => []);
+  const seen = /* @__PURE__ */ new Map();
+  for (const name of names) {
+    const path = join(profiles, name, "repos.manifest.yaml");
+    if (!await exists(path))
+      continue;
+    try {
+      const m = await loadManifest(path);
+      manifests.push({ platform: m.platform, path: rel(path), repos: m.repos.length });
+      for (const r of m.repos) {
+        const other = seen.get(r.id);
+        if (other) {
+          problems.push({ file: rel(path), message: `repo id ${r.id} is also in ${other}` });
+          continue;
+        }
+        seen.set(r.id, rel(path));
+        listed.push({
+          repo: {
+            id: r.id,
+            platform: m.platform,
+            type: r.type,
+            owner: r.owner,
+            manifest: rel(path),
+            // ADR 0128: what it is, in a person's words, or a draft waiting for one.
+            ...r.description ? { description: r.description } : {},
+            // ADR 0123: the branch the catalog is read from, and those scanned beside it.
+            defaultBranch: r.defaultBranch,
+            branches: r.branches
+          }
+        });
+      }
+    } catch (e) {
+      problems.push({ file: rel(path), message: firstLine(e) });
+    }
+  }
+  const catalog = await readCatalog(join(catalogDirOf(root), "generated"), { cacheRoot: root });
+  for (const p of catalog.problems)
+    problems.push({ file: rel(join(catalogDirOf(root), "generated", p.file)), message: p.message });
+  const scans = /* @__PURE__ */ new Map();
+  for (const r of catalog.records) {
+    const repos2 = new Set(r.evidence.map((e) => e.repo).filter((x) => !!x));
+    for (const repo of repos2) {
+      const s = scans.get(repo) ?? { records: 0, kinds: {} };
+      s.records += 1;
+      s.kinds[r.kind] = (s.kinds[r.kind] ?? 0) + 1;
+      for (const e of r.evidence) {
+        if (e.repo !== repo || !e.scannedAt)
+          continue;
+        if (!s.scannedAt || e.scannedAt > s.scannedAt) {
+          s.scannedAt = e.scannedAt;
+          if (e.commit)
+            s.commit = e.commit;
+        }
+      }
+      if (!s.commit) {
+        const c = r.evidence.find((e) => e.repo === repo && e.commit)?.commit;
+        if (c)
+          s.commit = c;
+      }
+      scans.set(repo, s);
+    }
+  }
+  const repos = [];
+  for (const { repo } of listed) {
+    const settings = join(orgPack, "scan", `${repo.id}.yaml`);
+    repos.push({
+      ...repo,
+      cloned: await exists(join(baseClonePath(root, repo.id), ".git")),
+      scanSettings: { path: rel(settings), present: await exists(settings) },
+      lastScan: scans.get(repo.id) ?? null
+    });
+  }
+  const sourcesFile = join(orgPack, "sources.yaml");
+  const sources = {
+    path: rel(sourcesFile),
+    present: await exists(sourcesFile),
+    wikis: [],
+    absorbed: []
+  };
+  if (sources.present) {
+    try {
+      const s = Sources.safeParse((0, import_yaml.parse)(await readFile(sourcesFile, "utf8")));
+      if (!s.success)
+        problems.push({
+          file: rel(sourcesFile),
+          message: s.error.issues.map((i) => `${i.path.map(String).join(".") || "(file)"}: ${i.message}`).join("; ")
+        });
+      else {
+        sources.wikis = s.data.wikis.map((w) => ({
+          id: w.id,
+          type: w.type,
+          location: w.location,
+          spaces: w.spaces,
+          ...w.owner ? { owner: w.owner } : {},
+          // 2.30.0 (ADR 0132): how much its word counts, and where it applies.
+          ...w.authority ? { authority: w.authority } : {},
+          ...w.appliesTo ? { scope: scopeWords(w.appliesTo) } : {}
+        }));
+        sources.absorbed = s.data.absorbed.map((a) => ({
+          id: a.id,
+          url: a.url,
+          format: a.format,
+          mode: a.mode
+        }));
+      }
+    } catch (e) {
+      problems.push({ file: rel(sourcesFile), message: `can't read YAML: ${firstLine(e)}` });
+    }
+  }
+  return {
+    manifests,
+    repos,
+    sources,
+    catalog: { records: catalog.records.length },
+    problems
+  };
+}
+function uiOnboardingRoutes(r, ctx) {
+  return r.add("GET", "/api/onboarding", async () => ({
+    status: 200,
+    body: await onboardingView(ctx.root)
+  }));
+}
+
+export {
+  onboardingView,
+  uiOnboardingRoutes
+};

package/dist/chunk-2UIQBDJO.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 {
+  readCatalog
+} from "./chunk-OLWFG75W.js";
+import {
+  VIEW_NAMES,
+  ViewError,
+  buildView,
+  shapeLibrary,
+  toDrawio,
+  toMermaid,
+  viewFromDiagram
+} from "./chunk-PAMPPUR6.js";
+import {
+  readDrawio
+} from "./chunk-7EKXJZ2Y.js";
+import {
+  loadOrgPack,
+  orgPackDirOf
+} from "./chunk-S2A7YC3Q.js";
+
+// packages/cli/dist/diagram-commands.js
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join, relative, resolve, sep } from "node:path";
+async function loadCatalog(root, io) {
+  const op = await loadOrgPack(join(orgPackDirOf(root)));
+  const catalogDir = join(root, op.sources.layout.catalog);
+  const generated = await readCatalog(join(catalogDir, "generated"), { cacheRoot: root });
+  const curated = await readCatalog(join(catalogDir, "curated"), { cacheRoot: root });
+  for (const p of [...generated.problems, ...curated.problems])
+    io.err(`catalog ${p.file}: ${p.message}`);
+  const legend = op.profiles[0]?.profile?.legend;
+  return {
+    records: [...generated.records, ...curated.records],
+    generated: generated.records.length,
+    ...legend ? { legend } : {}
+  };
+}
+async function emit(root, text, out, io) {
+  if (!out) {
+    io.out(text.replace(/\n$/, ""));
+    return;
+  }
+  const full = resolve(root, out);
+  await mkdir(dirname(full), { recursive: true });
+  await writeFile(full, text, "utf8");
+  io.out(`Wrote ${relative(root, full).split(sep).join("/")}.`);
+}
+async function diagramRender(root, o, io) {
+  const format = o.format ?? "mermaid";
+  if (format !== "mermaid" && format !== "drawio" && format !== "json") {
+    io.err(`Unknown format "${format}": use mermaid, drawio or json.`);
+    return 2;
+  }
+  if (/\.drawio(\.xml)?$/i.test(o.view)) {
+    if (format !== "mermaid") {
+      io.err("A diagram file renders as Mermaid only.");
+      return 2;
+    }
+    const full = resolve(root, o.view);
+    let xml;
+    try {
+      xml = await readFile(full, "utf8");
+    } catch {
+      io.err(`Can't read ${o.view}`);
+      return 2;
+    }
+    const op = await loadOrgPack(join(orgPackDirOf(root)));
+    const diagram = readDrawio(xml, op.profiles[0]?.profile?.legend);
+    for (const p of diagram.problems)
+      io.err(`cell ${p.cell}: ${p.message}`);
+    const view2 = viewFromDiagram(diagram, relative(root, full).split(sep).join("/"));
+    await emit(root, toMermaid(view2), o.out, io);
+    return 0;
+  }
+  if (!VIEW_NAMES.includes(o.view)) {
+    io.err(`Unknown view "${o.view}": use ${VIEW_NAMES.join(", ")}, or name a .drawio file to show it as Mermaid.`);
+    return 2;
+  }
+  const name = o.view;
+  if ((name === "container" || name === "sequence") && !o.focus) {
+    io.err(name === "container" ? "A container view needs a system: --focus <system>." : "A sequence view needs record ids in order: --focus <id>,<id>,...");
+    return 2;
+  }
+  if (name === "sequence" && format !== "mermaid") {
+    io.err("A sequence view renders as Mermaid only.");
+    return 2;
+  }
+  const { records, generated } = await loadCatalog(root, io);
+  if (generated === 0) {
+    io.err("The catalog is empty: read the repos first (atticus map <repo>, then atticus verify <repo> --write).");
+    return 1;
+  }
+  let view;
+  try {
+    view = buildView(records, name, o.focus);
+  } catch (e) {
+    if (e instanceof ViewError) {
+      io.err(e.message);
+      return 1;
+    }
+    throw e;
+  }
+  if (view.type !== "sequence" && view.nodes.length === 0) {
+    io.err(`Nothing to draw: the catalog has nothing for the ${name} view${o.focus ? ` of ${o.focus}` : ""}.`);
+    return 1;
+  }
+  if (format === "json" && view.type !== "sequence") {
+    await emit(root, JSON.stringify(view), o.out, io);
+    return 0;
+  }
+  await emit(root, view.type !== "sequence" && format === "drawio" ? toDrawio(view) : toMermaid(view), o.out, io);
+  return 0;
+}
+async function diagramLibrary(out, io) {
+  const full = resolve(out);
+  await mkdir(dirname(full), { recursive: true });
+  await writeFile(full, shapeLibrary(), "utf8");
+  io.out(`Wrote ${out}. In draw.io, open it with File > Open Library from > Device.`);
+  return 0;
+}
+
+export {
+  loadCatalog,
+  diagramRender,
+  diagramLibrary
+};