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

package/dist/chunk-V2TH46ZY.js

@@ -0,0 +1,66 @@
+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 {
+  loadCatalog
+} from "./chunk-P3TKKBAH.js";
+import "./chunk-AY2IUF4K.js";
+import {
+  domainProfile
+} from "./chunk-6JLPXDWN.js";
+import "./chunk-4GZXS6S2.js";
+import "./chunk-R4TBNKKC.js";
+import "./chunk-NIXVDQVO.js";
+import "./chunk-UR7RMZ3R.js";
+import "./chunk-PGKHJYOB.js";
+import "./chunk-MKRBG5EF.js";
+import "./chunk-5XDNUJ4P.js";
+import {
+  orgPackDirOf
+} from "./chunk-577AJVRS.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/domain-commands.js
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join, relative, resolve } from "node:path";
+var DOMAIN_PROFILE_TEMPLATE = "templates/domain-profile.md";
+async function domainProfileCommand(root, system, o, io) {
+  if (!system) {
+    io.err("Usage: atticus domain profile <system> [--out <file>]");
+    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;
+  }
+  const template = await readFile(join(orgPackDirOf(root), DOMAIN_PROFILE_TEMPLATE), "utf8").catch(() => void 0);
+  const scannedAt = records.flatMap((r) => r.evidence.map((e) => e.scannedAt ?? "")).sort().pop();
+  let text;
+  try {
+    text = domainProfile(records, system, {
+      ...template ? { template } : {},
+      ...scannedAt ? { scannedAt } : {}
+    });
+  } catch (e) {
+    io.err(e.message);
+    return 1;
+  }
+  if (!o.out) {
+    for (const line of text.replace(/\n$/, "").split("\n"))
+      io.out(line);
+    return 0;
+  }
+  const path = resolve(root, o.out);
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, text, "utf8");
+  io.out(`Wrote the ${system} domain profile to ${relative(root, path).split("\\").join("/")}${template ? ` (from org-pack/${DOMAIN_PROFILE_TEMPLATE})` : ""}. What the code can't tell is marked Unknown and listed under Open Questions.`);
+  return 0;
+}
+export {
+  DOMAIN_PROFILE_TEMPLATE,
+  domainProfileCommand
+};

package/dist/chunk-VKMTFIWS.js

@@ -0,0 +1,315 @@
+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-XIWYUQZQ.js";
+import {
+  loadCatalog
+} from "./chunk-P3TKKBAH.js";
+import {
+  repoFor
+} from "./chunk-XKS6THI5.js";
+import {
+  askHosts
+} from "./chunk-LRS573EX.js";
+import "./chunk-Y5PZHS4K.js";
+import {
+  estateFlow,
+  estateStepKey,
+  fieldLineage,
+  joinEstate
+} from "./chunk-AY2IUF4K.js";
+import "./chunk-6JLPXDWN.js";
+import "./chunk-4GZXS6S2.js";
+import "./chunk-R4TBNKKC.js";
+import "./chunk-NIXVDQVO.js";
+import "./chunk-UR7RMZ3R.js";
+import "./chunk-JF2NSTFO.js";
+import "./chunk-N4QZJJVB.js";
+import "./chunk-PGKHJYOB.js";
+import {
+  fsRepo
+} from "./chunk-MKRBG5EF.js";
+import "./chunk-5XDNUJ4P.js";
+import {
+  listQuestions,
+  loadOrgPack,
+  orgPackDirOf,
+  questionId,
+  raiseQuestions,
+  readEstateJoins,
+  readRepoSpec,
+  slugify,
+  specRepos,
+  specsRelOf,
+  templateRef,
+  writeEstateJoins
+} from "./chunk-577AJVRS.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/estate-commands.js
+var plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+var HOW = {
+  interface: "through the Interface",
+  endpoint: "to the entry point it names",
+  path: "by method and path"
+};
+var REASON = {
+  "no-target": "no target",
+  "no-flow": "no flow",
+  "no-citation": "no citation",
+  "family-mismatch": "a wrong family"
+};
+var ESTATE_TARGETS_STEP = "estate-targets";
+var ESTATE_TARGETS_NONE = "None of these";
+function estateAskDraft(a) {
+  return {
+    question: `Which component answers ${a.what}, which ${a.caller} calls?`,
+    options: [
+      ...a.candidates.map((c) => ({
+        label: c,
+        means: `${c} answers ${a.what}`,
+        changes: `The call-out joins ${c}'s flow at the next atticus estate join`
+      })),
+      {
+        label: ESTATE_TARGETS_NONE,
+        means: "None of these components answers it",
+        changes: "The call-out stays unjoined, and this isn't asked again"
+      }
+    ],
+    evidence: a.from.evidence ? [a.from.evidence] : [],
+    scope: "repo"
+  };
+}
+function estateAskId(a) {
+  const d = estateAskDraft(a);
+  return questionId({
+    step: ESTATE_TARGETS_STEP,
+    repo: a.from.repo,
+    question: d.question,
+    evidence: d.evidence
+  });
+}
+async function readSpecs(root, io, templates) {
+  const out = [];
+  for (const repo of await specRepos(root)) {
+    const s = await readRepoSpec(root, repo, { cacheRoot: root });
+    for (const p of s.problems)
+      io.err(`${p.file}: ${p.message}`);
+    if (s.flows.length)
+      out.push({ repo, flows: s.flows });
+    if (templates && s.header?.template)
+      templates[repo] = s.header.template;
+  }
+  return out;
+}
+async function specTemplates(root, refs) {
+  const op = await loadOrgPack(orgPackDirOf(root)).catch(() => void 0);
+  const out = {};
+  for (const [repo, ref] of Object.entries(refs)) {
+    const t = op?.specTemplates.find((x) => templateRef(x) === ref);
+    if (t)
+      out[repo] = t;
+  }
+  return out;
+}
+async function estateJoin(root, o, io) {
+  const refs = {};
+  const specs = await readSpecs(root, io, refs);
+  if (specs.length === 0) {
+    io.err(`There are no repo specs in ${specsRelOf(root)}/ yet. Draft them first: atticus spec draft <repo>.`);
+    return 2;
+  }
+  const { records } = await loadCatalog(root, { out: () => {
+  }, err: (l) => io.err(l) });
+  const templates = await specTemplates(root, refs);
+  const clones = /* @__PURE__ */ new Map();
+  const unchecked = /* @__PURE__ */ new Set();
+  const cited = async (repo, path, line) => {
+    if (!clones.has(repo)) {
+      const r2 = await repoFor(root, repo);
+      clones.set(repo, r2 ? { dir: r2.dir, lines: /* @__PURE__ */ new Map() } : null);
+      if (!r2)
+        unchecked.add(repo);
+    }
+    const c = clones.get(repo);
+    if (!c)
+      return true;
+    if (!c.lines.has(path)) {
+      const t = await fsRepo(repo, c.dir, "0".repeat(40)).readText(path).catch(() => void 0);
+      c.lines.set(path, t === void 0 ? 0 : t.replace(/\r\n?/g, "\n").replace(/\n$/, "").split("\n").length);
+    }
+    return line >= 1 && line <= c.lines.get(path);
+  };
+  const first = await joinEstate({ specs, records, cited, templates });
+  const askedBefore = new Map((await listQuestions(root, { step: ESTATE_TARGETS_STEP })).questions.map((q) => [q.id, q]));
+  const targets = {};
+  for (const a of first.asks) {
+    const q = askedBefore.get(estateAskId(a));
+    if (q?.state !== "answered" || !q.answer)
+      continue;
+    const label = q.answer.option !== void 0 ? q.options[q.answer.option - 1]?.label : q.answer.text;
+    if (label && label !== ESTATE_TARGETS_NONE)
+      targets[estateStepKey(a.from.flow, a.from.step)] = slugify(label);
+  }
+  const r = Object.keys(targets).length ? await joinEstate({ specs, records, cited, templates, targets }) : first;
+  const at = (o.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const asked = [];
+  for (const a of r.asks) {
+    if (!a.from.evidence)
+      continue;
+    const before = askedBefore.get(estateAskId(a));
+    if (before) {
+      if (before.state === "open")
+        asked.push({ q: before, raised: false });
+      continue;
+    }
+    const raised = await raiseQuestions(root, [estateAskDraft(a)], {
+      step: ESTATE_TARGETS_STEP,
+      repo: a.from.repo,
+      command: "atticus estate join",
+      rerun: "atticus estate join",
+      at
+    });
+    const q = raised.of[0];
+    if (q?.state === "open")
+      asked.push({ q, raised: raised.raised.some((x) => x.id === q.id) });
+  }
+  const inferred = new Set(r.inferred.map((x) => estateStepKey(x.from.flow, x.from.step)));
+  const file = {
+    schemaVersion: 1,
+    joinedAt: (o.now ?? /* @__PURE__ */ new Date()).toISOString(),
+    repos: specs.map((s) => s.repo),
+    joins: r.joins,
+    unmatched: r.unmatched
+  };
+  const rel = await writeEstateJoins(root, file);
+  const hosts = await askHosts(root, records, {
+    command: "atticus estate join",
+    ...o.now ? { now: o.now } : {}
+  });
+  if (o.json) {
+    io.out(JSON.stringify({
+      ...file,
+      file: rel,
+      unchecked: [...unchecked].sort(),
+      inferred: r.inferred,
+      asks: r.asks,
+      questions: [...hosts.raised, ...hosts.open, ...asked.map((x) => x.q)].map((q) => q.id)
+    }, null, 2));
+    return 0;
+  }
+  const total = r.joins.length + r.unmatched.length;
+  io.out(`Joined ${r.joins.length} of ${plural(total, "call-out")} across ${plural(specs.length, "repo")} (${file.repos.join(", ")}); written to ${rel}.`);
+  for (const j of r.joins)
+    io.out(`  ${j.from.flow} step ${j.from.step} \u2192 ${j.to.flow} (${HOW[j.how]}${j.interface ? ` ${j.interface}` : ""}${inferred.has(estateStepKey(j.from.flow, j.from.step)) ? ", inferred" : ""})`);
+  if (r.unmatched.length) {
+    io.out(`${plural(r.unmatched.length, "call-out")} ${r.unmatched.length === 1 ? "isn't" : "aren't"} joined:`);
+    for (const u of r.unmatched)
+      io.out(`  ${u.from.flow} step ${u.from.step} (${REASON[u.reason]}): ${u.message}`);
+  }
+  if (unchecked.size)
+    io.out(`Cited lines of ${[...unchecked].sort().join(", ")} weren't checked: there is no clone of ${unchecked.size === 1 ? "it" : "them"} here.`);
+  if (r.inferred.length)
+    io.out(`${plural(r.inferred.length, "join is", "joins are")} inferred: ${r.inferred.length === 1 ? "its" : "their"} step names a target that isn't a component in the catalog (a relative call's guessed name, or none), so ${r.inferred.length === 1 ? "it" : "each"} joined the only entry point that serves its method and path, the caller's own repo first. When the repo is next read, a relative call leaves \`to\` out or names the component that serves it.`);
+  for (const { q, raised } of asked)
+    io.out(raised ? `Two or more components answer a call-out: asked ${q.id}: ${q.question} Answer it: atticus questions answer ${q.id} --option <n>, then atticus estate join.` : `Still open: ${q.question} Answer it: atticus questions answer ${q.id} --option <n>, then atticus estate join.`);
+  for (const l of hosts.lines)
+    io.out(l);
+  io.out("Next: atticus estate flow <flow-id> follows a flow across repos.");
+  return 0;
+}
+async function loadJoined(root, flowId, depth, io) {
+  const joins = await readEstateJoins(root);
+  if (!joins) {
+    io.err(`There is no ${specsRelOf(root)}/estate.yaml yet. Join the repos' flows first: atticus estate join.`);
+    return void 0;
+  }
+  const f = estateFlow({
+    flow: flowId,
+    specs: await readSpecs(root, io),
+    joins,
+    ...depth !== void 0 ? { depth } : {}
+  });
+  if (!f)
+    io.err(`There is no flow ${flowId} in ${specsRelOf(root)}/.`);
+  return f;
+}
+var cite = (s) => {
+  const e = s.step.evidence[0];
+  return e?.path ? `  [${e.repo ?? s.repo}:${e.path}${e.line !== void 0 ? `:${e.line}` : ""}]` : "";
+};
+var list = (xs) => xs.length ? xs.join(", ") : "nothing named";
+function render(f, indent, out) {
+  for (const s of f.steps) {
+    out.push(`${indent}${s.n} ${s.step.kind}: ${s.step.what}${cite(s)}`);
+    const c = s.call;
+    if (!c)
+      continue;
+    const pad = `${indent}  `;
+    if (c.join) {
+      const callee = c.callee?.flow;
+      out.push(`${pad}\u2192 ${c.join.to.flow}${callee ? `: ${callee.name}` : ""} (${c.join.to.repo}), ${HOW[c.join.how]}${c.join.interface ? ` ${c.join.interface}` : ""}`);
+      const x = c.crossing;
+      out.push(`${pad}  sends ${list(x.sends)}; the callee takes ${list(x.receives)}; returns ${list(x.returns)}`);
+      for (const m of x.objects)
+        out.push(`${pad}  ${m.sent} carries the callee's ${m.fields.join(", ")}`);
+      if (x.unused.length)
+        out.push(`${pad}  sent but not used by the callee: ${x.unused.join(", ")}`);
+      if (c.callee)
+        render(c.callee, pad, out);
+      else if (c.stopped === "cycle")
+        out.push(`${pad}  (not followed: ${c.join.to.flow} is already on the path)`);
+      else if (c.stopped === "depth")
+        out.push(`${pad}  (not followed: the depth limit; raise --depth)`);
+    } else if (c.unmatched)
+      out.push(`${pad}\u2717 not joined (${REASON[c.unmatched.reason]}): ${c.unmatched.message}`);
+    else
+      out.push(`${pad}\u2717 not joined yet: the specs changed since atticus estate join ran`);
+  }
+}
+async function estateFlowCommand(root, flowId, o, io) {
+  const f = await loadJoined(root, flowId, o.depth, io);
+  if (!f)
+    return 2;
+  if (o.json) {
+    io.out(JSON.stringify(f, null, 2));
+    return 0;
+  }
+  const t = f.flow.trigger;
+  const e = t.evidence[0];
+  const out = [
+    `${f.flow.id}: ${f.flow.name} (${f.repo})`,
+    `Trigger (${t.kind}): ${t.what}${e?.path ? `  [${e.repo ?? f.repo}:${e.path}${e.line !== void 0 ? `:${e.line}` : ""}]` : ""}`
+  ];
+  render(f, "", out);
+  for (const l of out)
+    io.out(l);
+  return 0;
+}
+async function estateLineage(root, flowId, field, o, io) {
+  const f = await loadJoined(root, flowId, o.depth, io);
+  if (!f)
+    return 2;
+  const l = fieldLineage(f, field);
+  if (o.json) {
+    io.out(JSON.stringify(l, null, 2));
+    return l.stored ? 0 : 1;
+  }
+  io.out(`${field} along ${flowId}:`);
+  for (const k of l.links)
+    io.out(`  ${k.n} ${k.kind}, ${k.as} ${k.field}: ${k.what}${k.evidence ? `  [${k.evidence}]` : ""}`);
+  io.out(l.stored ? `${field} is stored in ${l.stored.table}.${l.stored.column}.` : `The chain breaks: ${l.breaks.message}`);
+  return l.stored ? 0 : 1;
+}
+export {
+  ESTATE_TARGETS_NONE,
+  ESTATE_TARGETS_STEP,
+  estateAskDraft,
+  estateAskId,
+  estateFlowCommand,
+  estateJoin,
+  estateLineage
+};

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
+};

package/dist/chunk-W5OYJMBT.js

@@ -0,0 +1,41 @@
+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 {
+  PluginProvider
+} from "./chunk-6EDQE7GO.js";
+import {
+  RuntimeConfigError,
+  registerModelProviderPluginLoader
+} from "./chunk-5XDNUJ4P.js";
+import "./chunk-577AJVRS.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/model-plugins.js
+async function pluginProviderFactory(p, deps = {}) {
+  const { readPinnedEntry, runTranslator } = await import("./chunk-YGKYFMSL.js");
+  const entry = await readPinnedEntry(p.dir, p.manifest);
+  if (!entry.ok)
+    throw new RuntimeConfigError(`The model-provider plugin org-pack/plugins/model-providers/${p.manifest.id}/ ${entry.message}.`);
+  const code = {
+    id: p.manifest.id,
+    version: p.manifest.version,
+    source: entry.source,
+    entry: p.manifest.entry,
+    limits: p.manifest.limits
+  };
+  return (settings) => new PluginProvider(p.manifest, settings, {
+    ...deps,
+    translate: (fn, arg) => runTranslator(code, fn, arg)
+  });
+}
+function registerModelProviderPlugins() {
+  registerModelProviderPluginLoader((p) => pluginProviderFactory(p));
+}
+export {
+  pluginProviderFactory,
+  registerModelProviderPlugins
+};