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

package/dist/chunk-WARBF2KY.js

@@ -0,0 +1,296 @@
+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 {
+  table
+} from "./chunk-VOGCSYOI.js";
+import {
+  readCatalog
+} from "./chunk-AY2IUF4K.js";
+import {
+  TriageError,
+  buildTriage,
+  classify,
+  scanInputs
+} from "./chunk-R4TBNKKC.js";
+import {
+  readDrawio,
+  reconcile
+} from "./chunk-NIXVDQVO.js";
+import {
+  inputsDirOf,
+  loadOrgPack,
+  orgPackDirOf,
+  recordPath,
+  serializeRecord
+} from "./chunk-577AJVRS.js";
+
+// packages/cli/dist/intake-commands.js
+import { createHash } from "node:crypto";
+import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { userInfo } from "node:os";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
+var inboxRelOf = (root) => relative(root, join(inputsDirOf(root), "inbox")).split(sep).join("/");
+async function filesUnder(dir) {
+  const out = [];
+  async function walk(d) {
+    let entries;
+    try {
+      entries = await readdir(d, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries.sort((a, b) => a.name < b.name ? -1 : 1)) {
+      const full = join(d, e.name);
+      if (e.isDirectory())
+        await walk(full);
+      else if (e.isFile())
+        out.push(full);
+    }
+  }
+  await walk(dir);
+  return out;
+}
+var sha256 = (b) => createHash("sha256").update(b).digest("hex");
+var rel = (root, p) => relative(root, p).split(sep).join("/");
+async function addToInbox(root, files) {
+  const INBOX = inboxRelOf(root);
+  const inbox = join(root, ...INBOX.split("/"));
+  const known = /* @__PURE__ */ new Map();
+  for (const f of await filesUnder(inputsDirOf(root)))
+    known.set(sha256(new Uint8Array(await readFile(f))), rel(root, f));
+  const added = [];
+  const refused = [];
+  for (const { name, bytes } of files) {
+    if (!name || /[\\/]/.test(name) || name === "." || name === "..") {
+      refused.push({ name, why: "give a file name without a folder in it" });
+      continue;
+    }
+    if (bytes.length === 0) {
+      refused.push({ name, why: "it is empty" });
+      continue;
+    }
+    const hash = sha256(bytes);
+    const already = known.get(hash);
+    if (already) {
+      refused.push({ name, why: `it is already in inputs as ${already}` });
+      continue;
+    }
+    const dot = name.lastIndexOf(".");
+    const [stem, ext] = dot > 0 ? [name.slice(0, dot), name.slice(dot)] : [name, ""];
+    await mkdir(inbox, { recursive: true });
+    const taken = new Set(await readdir(inbox));
+    let target = name;
+    for (let n = 2; taken.has(target); n++)
+      target = `${stem}-${n}${ext}`;
+    await writeFile(join(inbox, target), bytes);
+    const path = `${INBOX}/${target}`;
+    known.set(hash, path);
+    added.push({ name, path, kind: classify(target, bytes).classification });
+  }
+  return { added, refused };
+}
+async function intakeAdd(root, files, io) {
+  if (files.length === 0) {
+    io.err("Name at least one file to add.");
+    return 2;
+  }
+  let problems = false;
+  let added = 0;
+  let documents = 0;
+  const ALREADY = "it is already in inputs as ";
+  for (const f of files) {
+    const src = resolve(f);
+    let bytes;
+    try {
+      bytes = new Uint8Array(await readFile(src));
+    } catch {
+      io.err(`Can't read ${f}.`);
+      problems = true;
+      continue;
+    }
+    const r = await addToInbox(root, [{ name: basename(src), bytes }]);
+    for (const x of r.refused) {
+      io.err(x.why.startsWith(ALREADY) ? `${f} is already in inputs as ${x.why.slice(ALREADY.length)}; not copied.` : `${f} wasn't copied: ${x.why}.`);
+      problems = true;
+    }
+    for (const a of r.added) {
+      const reading = a.kind === "document" || a.kind === "image" ? ", needs reading" : "";
+      io.out(`Added ${a.path} (${a.kind}${reading}).`);
+      added++;
+      if (a.kind === "document")
+        documents++;
+    }
+  }
+  if (added > 0)
+    io.out("Run atticus intake list to see what Atticus made of them.");
+  if (documents > 0)
+    io.out("To read the documents into knowledge every change can use: atticus sources sync --source inputs, then atticus knowledge scan --source inputs.");
+  return problems ? 1 : 0;
+}
+async function intakeContext(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 inputs = await scanInputs({
+    root,
+    orgPack: op,
+    records: [...generated.records, ...curated.records],
+    inputsDir: inputsDirOf(root)
+  });
+  return { op, records: generated.records, curated: curated.records, inputs };
+}
+var STATUS_WORDS = [
+  ["read", (n) => `${n} read`],
+  ["needs-reading", (n) => `${n} need${n === 1 ? "s" : ""} reading`],
+  ["no-reader", (n) => `${n} with no reader yet`],
+  ["unresolved", (n) => `${n} waiting for a system name`],
+  ["duplicate", (n) => `${n} duplicate${n === 1 ? "" : "s"}`],
+  ["superseded", (n) => `${n} older version${n === 1 ? "" : "s"}`],
+  ["failed", (n) => `${n} failed`]
+];
+function chains(docs) {
+  const byId = new Map(docs.filter((d) => d.id).map((d) => [d.id, d]));
+  const replaced = new Set(docs.flatMap((d) => d.supersededBy ? [d.supersededBy] : []));
+  const out = [];
+  for (const d of docs) {
+    if (!d.supersededBy || d.id && replaced.has(d.id))
+      continue;
+    const chain = [d.path];
+    const seen = /* @__PURE__ */ new Set([d.id]);
+    for (let next = byId.get(d.supersededBy); next && !seen.has(next.id); ) {
+      chain.push(next.path);
+      seen.add(next.id);
+      next = next.supersededBy ? byId.get(next.supersededBy) : void 0;
+    }
+    out.push(chain);
+  }
+  return out;
+}
+async function intakeList(root, io, o) {
+  const { inputs } = await intakeContext(root, io);
+  const { documents, problems } = inputs;
+  if (o.json) {
+    io.out(JSON.stringify({ documents, chains: chains(documents), problems }, null, 2));
+    return problems.length > 0 ? 1 : 0;
+  }
+  if (documents.length === 0) {
+    io.out("Nothing in inputs/ yet: drop files into inputs/inbox/, or run atticus intake add <files>.");
+    return problems.length > 0 ? 1 : 0;
+  }
+  for (const l of table(["PATH", "TYPE", "STATUS", "SYSTEMS"], documents.map((d) => [
+    d.path,
+    d.classification,
+    d.duplicateOf ? `duplicate of ${d.duplicateOf}` : d.status,
+    d.systems.join(", ")
+  ])))
+    io.out(l);
+  const ch = chains(documents);
+  if (ch.length > 0) {
+    io.out("Versions:");
+    for (const c of ch)
+      io.out(`  ${c.join(" \u2192 ")}`);
+  }
+  const counts = STATUS_WORDS.map(([s, words]) => {
+    const n = documents.filter((d) => d.status === s).length;
+    return n > 0 ? words(n) : "";
+  }).filter(Boolean);
+  io.out(`${documents.length} file${documents.length === 1 ? "" : "s"}: ${counts.join(", ")}.`);
+  for (const p of problems)
+    io.out(`  ! ${p.path}: ${p.message}`);
+  return problems.length > 0 ? 1 : 0;
+}
+async function triageOf(root, io) {
+  const { op, records, curated, inputs } = await intakeContext(root, io);
+  if (records.length === 0 && inputs.documents.length > 0)
+    io.err("The catalog is empty: run atticus scan first, or most diagram edges will look unknown.");
+  const profile = op.profiles.find((p) => p.profile)?.profile;
+  const all = [...records, ...curated];
+  const reconcileItems = [];
+  for (const d of inputs.documents.filter((x) => x.classification === "diagram" && x.status === "read" && x.reader?.startsWith("drawio@"))) {
+    const xml = await readFile(join(root, ...d.path.split("/")), "utf8");
+    reconcileItems.push({
+      file: d.path,
+      items: reconcile({
+        diagram: readDrawio(xml, profile?.legend),
+        file: d.path,
+        records: all,
+        systems: profile?.systems ?? [],
+        patterns: op.patterns
+      }).items
+    });
+  }
+  return buildTriage({ records, inputs, decisions: curated, reconcileItems, ai: op.runtime.ai });
+}
+async function triageList(root, io, o) {
+  const { items } = await triageOf(root, io);
+  if (o.json) {
+    io.out(JSON.stringify({ items }, null, 2));
+    return items.length > 0 ? 1 : 0;
+  }
+  if (items.length === 0) {
+    io.out("Nothing to triage.");
+    return 0;
+  }
+  io.out(`${items.length} item${items.length === 1 ? "" : "s"} to decide.`);
+  for (const i of items) {
+    io.out("");
+    io.out(`${i.id} (${i.kind})`);
+    io.out(`  ${i.summary}`);
+    const where = `${i.source.path}${i.source.line ? `:${i.source.line}` : ""}`;
+    io.out(`  at ${where}${i.source.cell ? ` (cell ${i.source.cell})` : ""}`);
+    i.options.forEach((opt, n) => io.out(`  ${n + 1}. ${opt.label}`));
+    if (i.next)
+      io.out(`  \u2192 ${i.next}`);
+  }
+  io.out("");
+  io.out("Decide one with: atticus triage decide <item> <option>");
+  return 1;
+}
+async function triageDecide(root, itemId, option, o, io) {
+  const t = await triageOf(root, io);
+  const item = t.items.find((i) => i.id === itemId);
+  if (!item) {
+    io.err(`There is no open triage item ${itemId}. List them with: atticus triage`);
+    return 1;
+  }
+  if (!Number.isInteger(option) || option < 1 || option > item.options.length) {
+    const n = item.options.length;
+    io.err(`${itemId} has ${n} option${n === 1 ? "" : "s"}; pick 1 to ${n}.`);
+    return 2;
+  }
+  let decision;
+  try {
+    decision = t.decide(itemId, option - 1, {
+      by: o.by ?? userInfo().username,
+      ...o.reason ? { reason: o.reason } : {}
+    });
+  } catch (e) {
+    if (e instanceof TriageError) {
+      io.err(e.message);
+      return 1;
+    }
+    throw e;
+  }
+  const op = await loadOrgPack(join(orgPackDirOf(root)));
+  const relPath = `${op.sources.layout.catalog}/curated/${recordPath(decision)}`;
+  const full = join(root, ...relPath.split("/"));
+  await mkdir(dirname(full), { recursive: true });
+  await writeFile(full, serializeRecord(decision), "utf8");
+  io.out(`Wrote ${relPath}: ${item.options[option - 1].label}. Commit it so everyone's triage uses it.`);
+  return 0;
+}
+
+export {
+  addToInbox,
+  intakeAdd,
+  intakeContext,
+  intakeList,
+  triageList,
+  triageDecide
+};

package/dist/chunk-WGZWR4RF.js

@@ -0,0 +1,130 @@
+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 {
+  metarepoToolBox
+} from "./chunk-JF2NSTFO.js";
+import {
+  CONTEXT_TOOLS
+} from "./chunk-N4QZJJVB.js";
+import {
+  TOOL_LIMITS,
+  ToolSession,
+  readToolCalls,
+  recordToolCalls
+} from "./chunk-5XDNUJ4P.js";
+import "./chunk-577AJVRS.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/context-commands.js
+var box = (root) => metarepoToolBox(root);
+async function runFor(root, name, input, io) {
+  try {
+    io.out(await box(root).call(name, input));
+    return 0;
+  } catch (e) {
+    io.err(e.message);
+    return e.name === "ToolError" ? 2 : 1;
+  }
+}
+function contextShow(root, id, io) {
+  return runFor(root, "show", { id }, io);
+}
+function contextWalk(root, id, o, io) {
+  return runFor(root, "walk", {
+    id,
+    ...o.hops ? { hops: o.hops } : {},
+    ...o.kinds?.length ? { kinds: o.kinds } : {},
+    ...o.limit ? { limit: o.limit } : {}
+  }, io);
+}
+function contextCode(root, o, io) {
+  return runFor(root, "show_code", {
+    ...o.id ? { id: o.id } : {},
+    ...o.repo ? { repo: o.repo } : {},
+    ...o.path ? { path: o.path } : {},
+    ...o.line ? { line: o.line } : {},
+    ...o.around !== void 0 ? { context: o.around } : {}
+  }, io);
+}
+function contextGrep(root, pattern, o, io) {
+  return runFor(root, "grep", {
+    pattern,
+    ...o.regex ? { regex: true } : {},
+    ...o.ignoreCase ? { ignoreCase: true } : {},
+    ...o.repo ? { repo: o.repo } : {},
+    ...o.paths ? { paths: o.paths } : {},
+    ...o.limit ? { limit: o.limit } : {}
+  }, io);
+}
+function contextFiles(root, glob, o, io) {
+  return runFor(root, "files", { glob, ...o.repo ? { repo: o.repo } : {}, ...o.limit ? { limit: o.limit } : {} }, io);
+}
+function contextOutline(root, repo, path, io) {
+  return runFor(root, "outline", { repo, path }, io);
+}
+function contextSimilar(root, id, o, io) {
+  return runFor(root, "similar", { id, ...o.kinds?.length ? { kinds: o.kinds } : {}, ...o.limit ? { limit: o.limit } : {} }, io);
+}
+function contextTools(o, io) {
+  if (o.json) {
+    io.out(JSON.stringify({ tools: CONTEXT_TOOLS, limits: TOOL_LIMITS }, null, 2));
+    return 0;
+  }
+  for (const t of CONTEXT_TOOLS)
+    io.out(`${t.name}: ${t.description}`);
+  io.out(`At most ${TOOL_LIMITS.rounds} rounds of tool calls in a run, ${TOOL_LIMITS.tokens} tokens from tools in all, ${TOOL_LIMITS.perCall} from one call.`);
+  return 0;
+}
+async function contextCall(root, name, o, io) {
+  let input = {};
+  if (o.input !== void 0) {
+    try {
+      const v = JSON.parse(o.input);
+      if (typeof v !== "object" || v === null || Array.isArray(v))
+        throw new Error("not an object");
+      input = v;
+    } catch {
+      io.err(`--input is the tool's input as a JSON object, for example --input '{"id":"forge-ledger"}'.`);
+      return 2;
+    }
+  }
+  const existing = o.run ? await readToolCalls(root, o.run) : void 0;
+  if (o.run && !existing) {
+    io.err(`There is no run ${o.run}. atticus runs lists them.`);
+    return 2;
+  }
+  const session = new ToolSession(metarepoToolBox(root, existing?.tools?.calls), {}, existing?.tools);
+  const before = session.calls.length;
+  const call = await session.run(o.round ?? 1, { name, input });
+  if (o.run)
+    await recordToolCalls(root, o.run, (t) => ({
+      offered: CONTEXT_TOOLS.map((d) => d.name),
+      calls: [...t?.calls ?? [], ...session.calls.slice(before)],
+      ...session.stopped ? { stopped: session.stopped } : {}
+    }));
+  if (o.json)
+    io.out(JSON.stringify({
+      output: call.output,
+      tokens: call.tokens,
+      ...call.error ? { error: true } : {},
+      ...session.stopped ? { stopped: session.stopped } : {}
+    }, null, 2));
+  else
+    io.out(call.output);
+  return 0;
+}
+export {
+  contextCall,
+  contextCode,
+  contextFiles,
+  contextGrep,
+  contextOutline,
+  contextShow,
+  contextSimilar,
+  contextTools,
+  contextWalk
+};

package/dist/chunk-WLIIQ2A4.js

@@ -0,0 +1,18 @@
+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 {
+  conformanceCommand
+} from "./chunk-XRO65C7V.js";
+import "./chunk-PIVKU64W.js";
+import "./chunk-NGPU2ARF.js";
+import "./chunk-UR7RMZ3R.js";
+import "./chunk-MKRBG5EF.js";
+import "./chunk-577AJVRS.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+export {
+  conformanceCommand
+};

package/dist/chunk-X4W4XXWP.js

@@ -0,0 +1,134 @@
+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 {
+  targetFlowsOf
+} from "./chunk-67J3VZBA.js";
+import {
+  estimateChange,
+  loadRelease,
+  releaseForecast
+} from "./chunk-5YIBJXGB.js";
+import {
+  gateStatus,
+  reviewedGates
+} from "./chunk-47QE246J.js";
+import {
+  detectConflicts,
+  outsideSystemsOf
+} from "./chunk-XQ3YIV5R.js";
+import {
+  loadEstimates,
+  loadOrgPack,
+  orgPackDirOf
+} from "./chunk-577AJVRS.js";
+
+// packages/cli/dist/change-estimate.js
+import { relative, sep } from "node:path";
+async function estimateOf(root, change, o = {}) {
+  const t = await targetFlowsOf(root, change);
+  if (!t)
+    return void 0;
+  const problems = [...t.problems];
+  const { estimates, problem } = await loadEstimates(orgPackDirOf(root));
+  if (problem)
+    problems.push(problem);
+  const systems = /* @__PURE__ */ new Map();
+  const systemOf = /* @__PURE__ */ new Map();
+  for (const r of t.records) {
+    if (r.kind === "System")
+      systems.set(r.id, r.boundary);
+    if (r.kind === "Component")
+      systemOf.set(r.id, r.system);
+  }
+  const boundaryOf = (c) => systems.get(systemOf.get(c) ?? c);
+  const op = await loadOrgPack(orgPackDirOf(root)).catch(() => void 0);
+  const outside = op ? outsideSystemsOf(op) : /* @__PURE__ */ new Map();
+  const otherTeam = (c) => boundaryOf(c) !== "vendor" && outside.get(systemOf.get(c) ?? c) === "other-team";
+  let openBlocking = 0;
+  for (const gate of await reviewedGates(root, change).catch(() => []))
+    openBlocking += await gateStatus(root, change, gate).then((s) => s.open.blocking, () => 0);
+  const conflicts = (await detectConflicts(root).catch(() => [])).filter((p) => p.changes.includes(change)).length;
+  let waitDays;
+  try {
+    const f = await releaseForecast(await loadRelease(root, change, o.now ? { now: o.now } : {}));
+    if (f.status !== "released")
+      waitDays = f.waitDays;
+  } catch (e2) {
+    problems.push(`The release forecast couldn't be worked out: ${e2.message.split("\n")[0]}`);
+  }
+  const flows = t.merged.map((m) => ({
+    flow: m.flow,
+    repo: m.repo,
+    change: m.change,
+    trigger: m.trigger.kind,
+    file: `${t.source}/${m.flow}.yaml`,
+    steps: m.steps.map((s) => ({
+      mark: s.mark,
+      kind: s.kind,
+      ...s.today !== void 0 ? { today: s.today } : {},
+      ...s.target !== void 0 ? { target: s.target } : {},
+      ...s.what ? { what: s.what } : {},
+      ...s.to ? { to: s.to } : {},
+      ...s.store ? { store: s.store } : {},
+      ...s.confirmedBy ? { confirmedBy: s.confirmedBy } : {}
+    }))
+  }));
+  const e = estimateChange({
+    change,
+    flows,
+    ...estimates ? { table: estimates } : {},
+    boundaryOf,
+    otherTeam,
+    openBlocking,
+    conflicts,
+    ...waitDays !== void 0 ? { waitDays } : {}
+  });
+  return {
+    ...e,
+    title: t.title,
+    source: t.source,
+    ...estimates ? { table: `${relative(root, orgPackDirOf(root)).split(sep).join("/")}/estimates.yaml` } : {},
+    problems
+  };
+}
+var units = (n) => `${n} unit${n === 1 ? "" : "s"} of work`;
+var range = (d) => `${d.p20}-${d.p80} days (p50 ${d.p50})`;
+async function changeEstimateCommand(root, change, o, io) {
+  const e = await estimateOf(root, change, o.now ? { now: o.now } : {});
+  if (!e) {
+    io.err(`There is no change ${change}.`);
+    return 2;
+  }
+  if (o.json) {
+    io.out(JSON.stringify(e, null, 2));
+    return 0;
+  }
+  for (const p of e.problems)
+    io.err(p);
+  if (!e.units.length) {
+    io.err(`${change} has no target flows yet, so there is nothing to size: the architecture stage writes them (atticus change architecture ${change}).`);
+    return 1;
+  }
+  io.out(`Estimate for ${change}: ${e.title}`);
+  io.out(e.effort ? `Effort: ${range(e.effort)}, from ${e.units.length - e.needsClass} of ${units(e.units.length)}.` : `Size: ${units(e.units.length)}. No days: ${e.table ? "no class in the org pack's estimates.yaml matches them" : "the org pack has no estimates.yaml"}.`);
+  if (e.calendar.waitDays !== void 0)
+    io.out(`Waiting (the release forecast): ${e.calendar.waitDays} working days${e.calendar.longer ? `; the ${e.calendar.longer} is longer` : ""}.`);
+  io.out(e.calibration.source ? `Not calibrated yet: the ranges are ${e.calibration.source}'s, from ${e.table}.` : "Not calibrated yet.");
+  if (e.drivers.length) {
+    io.out("Drivers:");
+    for (const d of e.drivers)
+      io.out(`  ${d.what}: ${d.count}${d.widens ? ` (widens the upper end by ${d.widens}x)` : ""}${d.source ? `  ${d.source}` : ""}`);
+  }
+  io.out("Work:");
+  for (const u of e.units)
+    io.out(`  ${u.repo}  ${u.flow}${u.step !== void 0 ? ` step ${u.step}` : ""}  ${u.class}  ${u.days ? range(u.days) : "needs a class"}  ${u.what}`);
+  return 0;
+}
+
+export {
+  estimateOf,
+  changeEstimateCommand
+};