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

package/dist/chunk-VF4IOZZO.js

@@ -0,0 +1,184 @@
+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 {
+  InitiativeError,
+  JOURNEYS,
+  initiativeStatus,
+  newInitiative,
+  planJourney,
+  recordCommitment,
+  requestFromTeam
+} from "./chunk-ZUIAOKXI.js";
+import {
+  table
+} from "./chunk-VOGCSYOI.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-KJPMEAI4.js";
+import "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/initiative-commands.js
+function fail(io, e) {
+  if (e instanceof InitiativeError) {
+    io.err(e.message);
+    return e.code === "usage" ? 2 : 1;
+  }
+  throw e;
+}
+async function initiativeNew(root, o, io) {
+  if (!o.title || !o.journey || !o.by) {
+    io.err(`Usage: atticus initiative new "<title>" --journey <${JOURNEYS.join("|")}> [--by <you>] [--release YYYY-MM-DD]`);
+    return 2;
+  }
+  try {
+    const r = await newInitiative(root, {
+      title: o.title,
+      journey: o.journey,
+      by: o.by,
+      ...o.id ? { id: o.id } : {},
+      ...o.release ? { targetRelease: o.release } : {},
+      ...o.epic ? { adoEpic: o.epic } : {}
+    });
+    if (o.json) {
+      io.out(JSON.stringify(r, null, 2));
+      return 0;
+    }
+    io.out(`Started ${r.initiative.id} (${r.initiative.journey}). Wrote ${r.written}.`);
+    io.out(`Plan it: atticus initiative plan ${r.initiative.id} --target <system>${o.release ? "" : " --release YYYY-MM-DD"}`);
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function initiativePlan(root, id, o, io, deps = {}) {
+  if (!id || !o.by) {
+    io.err("Usage: atticus initiative plan <id> --target <system> [--release YYYY-MM-DD] [--by <you>] [--dry-run]");
+    return 2;
+  }
+  try {
+    const r = await planJourney(root, id, {
+      by: o.by,
+      ...o.target ? { target: o.target } : {},
+      ...o.release ? { targetRelease: o.release } : {},
+      ...o.systems?.length ? { systems: o.systems } : {},
+      ...o.dryRun ? { dryRun: true } : {},
+      ...deps.now ? { now: deps.now } : {}
+    });
+    if (o.json) {
+      io.out(JSON.stringify(r, null, 2));
+      return 0;
+    }
+    io.out(`${r.initiative.title}: ${r.plan.items.length} items from ${r.plan.target} back to ${r.plan.targetRelease} (${r.plan.journey} journey, ${r.plan.journeySource}).`);
+    for (const l of table(["ITEM", "KIND", "WITH", "START", "DUE", "DAYS", "LEAD TIME FROM"], r.plan.items.map((i) => [
+      i.key,
+      i.kind,
+      i.party ?? i.change ?? i.owner ?? "",
+      i.start,
+      i.due,
+      String(i.days),
+      i.leadTime
+    ])))
+      io.out(l);
+    if (r.changes.length) {
+      io.out("Changes to start:");
+      for (const c of r.changes)
+        io.out(`  ${c.command}`);
+    }
+    for (const n of r.notes)
+      io.out(`Note: ${n}`);
+    io.out(o.dryRun ? "Dry run: nothing written." : `Wrote ${r.written.length} files (the plan and ${r.commitments.length} commitments).`);
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function initiativeStatus2(root, id, o, io, deps = {}) {
+  if (!id) {
+    io.err("Usage: atticus initiative status <id> [--json]");
+    return 2;
+  }
+  try {
+    const s = await initiativeStatus(root, id, deps.now ? { now: deps.now } : {});
+    const bad = s.status === "at-risk" || s.status === "slipped";
+    if (o.json) {
+      io.out(JSON.stringify(s, null, 2));
+      return bad ? 1 : 0;
+    }
+    io.out(`${s.title} (${s.journey}): ${s.status}${s.targetRelease ? `; target ${s.targetRelease}` : ""}${s.projectedRelease ? `, projected ${s.projectedRelease}` : ""}.`);
+    if (s.criticalPath.length)
+      io.out(`Critical path: ${s.criticalPath.join(" \u2192 ")}`);
+    if (s.items.length)
+      for (const l of table(["ITEM", "STATUS", "DUE", "PROJECTED", "FLOAT", "WHY"], s.items.map((i) => [i.key, i.status, i.due, i.projectedFinish, String(i.float), i.why])))
+        io.out(l);
+    const open = s.commitments.filter((c) => c.status === "slipped" || c.status === "at-risk");
+    if (open.length) {
+      io.out("Commitments slipped or at risk:");
+      for (const c of open)
+        io.out(`  ${c.id} (${c.party}, needed by ${c.neededBy}): ${c.status}. ${c.why}`);
+    }
+    for (const n of s.notes)
+      io.out(`Note: ${n}`);
+    return bad ? 1 : 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function requestFromTeam2(root, initiativeId, partyId, o, io, deps = {}) {
+  if (!initiativeId || !partyId || !o.by) {
+    io.err("Usage: atticus initiative request <id> <party> [--by <you>] [--system s]...");
+    return 2;
+  }
+  try {
+    const r = await requestFromTeam(root, initiativeId, partyId, {
+      by: o.by,
+      ...o.systems?.length ? { systems: o.systems } : {},
+      ...deps.now ? { now: deps.now } : {}
+    });
+    if (o.json) {
+      io.out(JSON.stringify({ ...r, card: void 0 }, null, 2));
+      return 0;
+    }
+    io.out(`Wrote the system card ${r.cardPath}.`);
+    io.out(`Tracked as ${r.commitment.id}: reply needed by ${r.commitment.neededBy}.`);
+    io.out(`Send it: atticus todo show ${r.step.id} (then atticus todo done ${r.step.id}).`);
+    io.out("When the reply comes, add it with atticus intake add <file>.");
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function initiativeCommitment(root, id, status, o, io) {
+  const states = ["open", "at-risk", "done", "slipped"];
+  if (!id || !status || !o.by || !states.includes(status)) {
+    io.err(`Usage: atticus initiative commit <commitment> <${states.join("|")}> [--by <you>]`);
+    return 2;
+  }
+  try {
+    const r = await recordCommitment(root, id, { status, by: o.by });
+    io.out(`${r.commitment.id} is ${status}. Wrote ${r.written}.`);
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+export {
+  initiativeCommitment,
+  initiativeNew,
+  initiativePlan,
+  initiativeStatus2 as initiativeStatus,
+  requestFromTeam2 as requestFromTeam
+};

package/dist/chunk-VJTINHZI.js

@@ -0,0 +1,48 @@
+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 {
+  benchFactsCommand,
+  benchFetch,
+  benchRepos,
+  benchResults,
+  benchRun,
+  benchSurvey,
+  benchVerify
+} from "./chunk-CP3L3FH7.js";
+import "./chunk-STUPFGXY.js";
+import "./chunk-RYSCLMU3.js";
+import "./chunk-ZUIAOKXI.js";
+import "./chunk-DPC5Y5DL.js";
+import "./chunk-6SCVQZX5.js";
+import "./chunk-65NYPGRC.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 {
+  benchFactsCommand,
+  benchFetch,
+  benchRepos,
+  benchResults,
+  benchRun,
+  benchSurvey,
+  benchVerify
+};

package/dist/chunk-VKLILA2D.js

@@ -0,0 +1,205 @@
+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 {
+  intakeContext
+} from "./chunk-FVQISWPW.js";
+import "./chunk-VOGCSYOI.js";
+import {
+  estateFacts,
+  estateRepos,
+  joinReposOf
+} from "./chunk-OLWFG75W.js";
+import "./chunk-L24C55VN.js";
+import "./chunk-PAMPPUR6.js";
+import {
+  readVendorSpec,
+  slug,
+  vendorImpact
+} from "./chunk-23W7VWKR.js";
+import "./chunk-7EKXJZ2Y.js";
+import "./chunk-MC3H7736.js";
+import "./chunk-KJPMEAI4.js";
+import "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import {
+  inputsDirOf,
+  readFlow,
+  specFlowFiles
+} from "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/vendor-impact-commands.js
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+var IMPACT_WORDS = {
+  usage: "Name the vendor spec: atticus intake impact <spec> [--json]",
+  noSuchSpec: (spec) => `There is no ${spec} in inputs/. atticus intake list shows what is there.`,
+  notASpec: (path) => `${path} isn't an OpenAPI 3 or Swagger 2 spec, so it has no operations to compare.`,
+  noOtherVersion: (path) => `${path} has no other version beside it in inputs/, so there is nothing to compare. Add each version of a vendor's spec beside the last (atticus intake add), never over it.`,
+  noSystem: (path) => `${path} isn't linked to a system yet, so its operations belong to nobody. atticus triage asks which system it is.`,
+  header: (name, older, newer) => `${name}: ${older.path}${older.version ? ` (${older.version})` : ""} \u2192 ${newer.path}${newer.version ? ` (${newer.version})` : ""}`,
+  counts: (all, breaking) => all === 0 ? "The two versions publish the same operations, fields and auth." : `${all} change${all === 1 ? "" : "s"}: ${breaking} breaking, ${all - breaking} additive.`,
+  severity: { breaking: "Breaking", additive: "Additive" },
+  reachesNothing: "Nothing in the estate reaches it.",
+  gap: (message, where2) => `Forwarded, but not in the older version either: ${message} (${where2}).`,
+  ask: (question) => `Asked: ${question}`,
+  affected: (repos, flows) => `Affected: ${repos.join(", ")}${flows.length ? `; flows ${flows.join(", ")}` : ""}.`,
+  nothingAffected: "Nothing in the estate reaches these changes.",
+  start: (spec) => `Start a change with this as its footprint: atticus change new "<title>" --type <type> --impact ${spec}`,
+  docTitle: (name, version) => `# What ${name} ${version} changes, and what in the estate it reaches`,
+  started: (name, version, i, attached) => `Its footprint is what ${name} ${version} reaches: ${i.repos.length} repo${i.repos.length === 1 ? "" : "s"}, ${i.flows.length} flow${i.flows.length === 1 ? "" : "s"}, ${i.interfaces.length} Interface${i.interfaces.length === 1 ? "" : "s"}. The impact is attached as ${attached}.`
+};
+var posix = (p) => p.split(sep).join("/");
+var SPECS = /* @__PURE__ */ new Set(["openapi", "swagger"]);
+function findDocument(root, docs, spec) {
+  const kept = docs.filter((d) => d.id);
+  if (!isAbsolute(spec) && spec.includes("/") && existsSync(resolve(spec)))
+    spec = resolve(spec);
+  const rel = isAbsolute(spec) ? `inputs/${posix(relative(inputsDirOf(root), spec))}` : posix(spec);
+  return kept.find((d) => d.path === rel) ?? kept.find((d) => d.path === `inputs/${rel}`) ?? kept.find((d) => d.id === spec) ?? (() => {
+    const named = kept.filter((d) => d.path.split("/").pop() === rel);
+    return named.length === 1 ? named[0] : void 0;
+  })();
+}
+async function loadVendorImpact(root, spec, io) {
+  const { op, inputs } = await intakeContext(root, io);
+  const doc = findDocument(root, inputs.documents, spec);
+  if (!doc)
+    return { error: IMPACT_WORDS.noSuchSpec(spec) };
+  if (!SPECS.has(doc.classification))
+    return { error: IMPACT_WORDS.notASpec(doc.path) };
+  const byId = new Map(inputs.documents.filter((d) => d.id).map((d) => [d.id, d]));
+  const older = doc.supersededBy ? doc : inputs.documents.find((d) => d.supersededBy === doc.id && SPECS.has(d.classification));
+  const newer = doc.supersededBy ? byId.get(doc.supersededBy) : doc;
+  if (!older || !newer || !SPECS.has(newer.classification))
+    return { error: IMPACT_WORDS.noOtherVersion(doc.path) };
+  const systemId = newer.systems[0] ?? older.systems[0];
+  const system = op.profiles.flatMap((p) => p.profile?.systems ?? []).find((s) => s.id === systemId);
+  if (!systemId || !system)
+    return { error: IMPACT_WORDS.noSystem(newer.path) };
+  const inputsDir = inputsDirOf(root);
+  const read = async (d) => readVendorSpec(d.path, await readFile(join(inputsDir, ...d.path.split("/").slice(1)), "utf8"), systemId);
+  const [olderSpec, newerSpec] = [await read(older), await read(newer)];
+  if (!olderSpec)
+    return { error: IMPACT_WORDS.notASpec(older.path) };
+  if (!newerSpec)
+    return { error: IMPACT_WORDS.notASpec(newer.path) };
+  const estate = await estateFacts(root, op, "");
+  const repos = joinReposOf(op, estate.repos);
+  const flows = [];
+  for (const [id, f] of await specFlowFiles(root).catch(() => /* @__PURE__ */ new Map())) {
+    const flow = await readFlow(root, f.repo, id).catch(() => void 0);
+    if (!flow)
+      continue;
+    flows.push({
+      id,
+      repo: f.repo,
+      ...flow.trigger.ref ? { trigger: flow.trigger.ref } : {},
+      refs: flow.steps.flatMap((s) => s.refs ?? [])
+    });
+  }
+  const systemOfRepo = Object.fromEntries(estateRepos(op).flatMap((r) => r.system ? [[r.id, r.system]] : []));
+  const { diff, impact } = vendorImpact({
+    vendor: { system: systemId, names: [system.name, ...system.aliases] },
+    older: { id: older.id, spec: olderSpec },
+    newer: { id: newer.id, spec: newerSpec },
+    repos,
+    targets: estate.targets,
+    flows,
+    systemOfRepo
+  });
+  const facts = /* @__PURE__ */ new Map();
+  for (const r of estate.repos)
+    for (const f of r.facts)
+      facts.set(`${r.repo}\0${f.id}`, f);
+  return { name: system.name, diff, impact, notes: estate.notes, facts };
+}
+var where = (e) => `${e.repo} ${e.at}`;
+function impactLines(l) {
+  const { impact, diff } = l;
+  const out = [];
+  out.push(IMPACT_WORDS.header(l.name, impact.older, impact.newer));
+  out.push(IMPACT_WORDS.counts(diff.length, diff.filter((c) => c.severity === "breaking").length));
+  const byId = new Map(diff.map((c) => [c.id, c]));
+  for (const c of impact.changes) {
+    const d = byId.get(c.id);
+    out.push("");
+    out.push(`${IMPACT_WORDS.severity[c.severity]}: ${c.says}`);
+    const cites = [
+      ...d.before ? [`was ${d.before.cite}`] : [],
+      ...d.after ? [`now ${d.after.cite}`] : []
+    ];
+    if (cites.length)
+      out.push(`  ${cites.join(", ")}`);
+    if (!c.forwards.length)
+      out.push(`  ${IMPACT_WORDS.reachesNothing}`);
+    for (const f of c.forwards) {
+      const call = l.facts.get(`${f.call.repo}\0${f.call.fact}`);
+      const what = call?.kind === "call" ? [call.method?.toUpperCase(), call.path].filter(Boolean).join(" ") : f.call.fact;
+      const to = f.tie ? `to ${l.name} through ${f.tie.at}` : `to ${l.name}`;
+      out.push(`  forwarded by ${f.call.component}: ${what}, ${where(f.call)} (${to})`);
+      for (const s of f.callers) {
+        const field = s.field ? s.field.uses === "sends" || s.field.uses === "reads" ? `, ${s.field.uses} ${d.field}${s.field.at ? ` (${s.field.at})` : ""}` : `, ${s.field.uses === "does-not-send" ? "doesn't send" : "doesn't read"} ${d.field}` : "";
+        const via = s.via?.length ? `, through ${s.via.join(" \u2192 ")}` : "";
+        out.push(`    called by ${s.call.component}: ${where(s.call)}${field}${via}`);
+        if (s.under)
+          out.push(`      under ${where(s.under)}`);
+        for (const u of s.upstream) {
+          const uvia = u.via?.length ? `, through ${u.via.join(" \u2192 ")}` : "";
+          out.push(`      \u2190 ${u.call.component}: ${where(u.call)}${uvia}${u.under ? `, under ${where(u.under)}` : ""}`);
+        }
+      }
+    }
+  }
+  if (impact.gaps.length || impact.asks.length)
+    out.push("");
+  for (const g of impact.gaps)
+    out.push(IMPACT_WORDS.gap(g.message, where(g.call)));
+  for (const a of impact.asks)
+    out.push(IMPACT_WORDS.ask(a.question));
+  out.push("");
+  out.push(impact.repos.length ? IMPACT_WORDS.affected(impact.repos, impact.flows.map((f) => f.id)) : IMPACT_WORDS.nothingAffected);
+  return out;
+}
+async function intakeImpact(root, spec, o, io) {
+  if (!spec) {
+    io.err(IMPACT_WORDS.usage);
+    return 2;
+  }
+  const l = await loadVendorImpact(root, spec, io);
+  if ("error" in l) {
+    io.err(l.error);
+    return 1;
+  }
+  for (const n of l.notes)
+    io.err(n);
+  const reaches = l.impact.changes.some((c) => c.severity === "breaking" && c.forwards.length > 0);
+  if (o.json) {
+    io.out(JSON.stringify({ diff: l.diff, impact: l.impact }, null, 2));
+    return reaches ? 1 : 0;
+  }
+  for (const line of impactLines(l))
+    io.out(line);
+  if (l.impact.repos.length)
+    io.out(IMPACT_WORDS.start(l.impact.newer.path));
+  return reaches ? 1 : 0;
+}
+function impactDocument(l) {
+  const version = l.impact.newer.version ?? l.impact.newer.id;
+  return {
+    name: `${slug(`${l.name} ${version}`)}-impact.md`,
+    text: [IMPACT_WORDS.docTitle(l.name, version), "", ...impactLines(l), ""].join("\n")
+  };
+}
+export {
+  IMPACT_WORDS,
+  impactDocument,
+  impactLines,
+  intakeImpact,
+  loadVendorImpact
+};

package/dist/chunk-VOGCSYOI.js

@@ -0,0 +1,16 @@
+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));
+
+// packages/cli/dist/table.js
+function table(header, rows) {
+  const widths = header.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length)));
+  const line = (cells) => cells.map((c, i) => i === cells.length - 1 ? c : c.padEnd(widths[i])).join("  ").trimEnd();
+  return [line(header), ...rows.map(line)];
+}
+
+export {
+  table
+};