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

package/dist/chunk-Y7KBQ4BD.js

@@ -0,0 +1,230 @@
+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 {
+  renderTaskContext,
+  taskContext
+} from "./chunk-KC5DROFC.js";
+import "./chunk-RK6MKKKP.js";
+import "./chunk-47QE246J.js";
+import {
+  changeFolder,
+  changeStore
+} from "./chunk-XQ3YIV5R.js";
+import "./chunk-MGVYVW7Q.js";
+import "./chunk-NGPU2ARF.js";
+import "./chunk-AY2IUF4K.js";
+import "./chunk-6JLPXDWN.js";
+import "./chunk-4GZXS6S2.js";
+import {
+  attachToChange
+} from "./chunk-R4TBNKKC.js";
+import "./chunk-NIXVDQVO.js";
+import "./chunk-UR7RMZ3R.js";
+import "./chunk-N4QZJJVB.js";
+import "./chunk-PGKHJYOB.js";
+import "./chunk-MKRBG5EF.js";
+import "./chunk-5XDNUJ4P.js";
+import {
+  changesRelOf,
+  inputsDirOf
+} from "./chunk-577AJVRS.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/attach-commands.js
+import { createHash } from "node:crypto";
+import { readdir, readFile } from "node:fs/promises";
+import { basename, join, relative, resolve, sep } from "node:path";
+var sha256 = (b) => createHash("sha256").update(b).digest("hex");
+async function filesUnder(dir) {
+  const out = [];
+  const walk = async (d) => {
+    for (const e of await readdir(d, { withFileTypes: true }).catch(() => []))
+      if (e.isDirectory())
+        await walk(join(d, e.name));
+      else if (e.isFile())
+        out.push(join(d, e.name));
+  };
+  await walk(dir);
+  return out;
+}
+async function metarepoInputs(root) {
+  const out = /* @__PURE__ */ new Map();
+  for (const f of await filesUnder(inputsDirOf(root)))
+    out.set(sha256(new Uint8Array(await readFile(f))), relative(root, f).split(sep).join("/"));
+  return out;
+}
+var AttachError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "AttachError";
+  }
+};
+async function attachFiles(root, change, files, by, now = /* @__PURE__ */ new Date(), replaces) {
+  const c = await changeStore(root).read(change).catch(() => {
+    throw new AttachError("not-found", `There is no change ${change}: atticus change list shows them.`);
+  });
+  const known = await metarepoInputs(root);
+  return attachToChange(changeFolder(root, c.id), files, {
+    by,
+    at: now.toISOString().replace(/\.\d{3}Z$/, "Z"),
+    elsewhere: (h) => known.get(h),
+    ...replaces ? { replaces } : {}
+  });
+}
+async function promoteChangeInput(root, change, file) {
+  const c = await changeStore(root).read(change).catch(() => {
+    throw new AttachError("not-found", `There is no change ${change}: atticus change list shows them.`);
+  });
+  const name = file.replace(/^inputs\//, "");
+  if (!name || /[\\/]/.test(name) || name === "." || name === "..")
+    throw new AttachError("invalid", `Name one attached file, such as inputs/${basename(file) || "rules.pdf"}.`);
+  let bytes;
+  try {
+    bytes = new Uint8Array(await readFile(join(changeFolder(root, c.id), "inputs", name)));
+  } catch {
+    throw new AttachError("not-found", `inputs/${name} isn't attached to ${c.id}: atticus change attach ${c.id} adds it.`);
+  }
+  const { addToInbox } = await import("./chunk-NNUASOAA.js");
+  const r = await addToInbox(root, [{ name, bytes }]);
+  const added = r.added[0];
+  if (!added)
+    throw new AttachError("invalid", `inputs/${name}: ${r.refused[0]?.why ?? "refused"}`);
+  return {
+    path: added.path,
+    note: `Copied to ${added.path}: general knowledge, read at the next atticus sources sync. ${c.id} keeps its copy. Commit both through a pull request.`
+  };
+}
+function attachedLine(rel, a) {
+  const what = a.read === "text" ? `${a.kind}, ${a.format}; read, cited by ${a.citeBy}` : a.kind === "image" ? "a picture: your assistant looks at it in the chat; Atticus doesn't read pictures" : `${a.format}: no reader takes it, so the steps name it without its text`;
+  return `Attached ${rel}/${a.path} (${what})${a.supersedes ? `, a newer version of ${a.supersedes}` : ""}${a.defences ? `; the defences found ${a.defences.risk} risk` : ""}.`;
+}
+async function changeAttachCli(root, change, paths, o, io) {
+  if (change && o.prototype) {
+    if (paths.length) {
+      const { PROTOTYPE_CLI_WORDS } = await import("./chunk-LVGBKKSM.js");
+      io.err(PROTOTYPE_CLI_WORDS.usage(change, o.prototype));
+      return 2;
+    }
+    const { attachPrototype } = await import("./chunk-LVGBKKSM.js");
+    return attachPrototype(root, change, o.prototype, { by: o.by, ...o.json ? { json: true } : {}, ...o.now ? { now: o.now } : {} }, io);
+  }
+  if (change && o.like) {
+    if (paths.length) {
+      io.err("--like names an archived change, attached on its own: atticus change attach add-refund-window --like raise-transfer-limit");
+      return 2;
+    }
+    const { attachPastChange, findPastChange } = await import("./chunk-MF7QH4AX.js");
+    const folder = await findPastChange(root, o.like);
+    if (!folder) {
+      io.err(`There is no archived change ${o.like}: atticus change similar "<what it is about>" lists them.`);
+      return 1;
+    }
+    try {
+      const name = await attachPastChange(root, change, folder, o.by, o.now);
+      io.out(`Attached ${folder} as inputs/${name}: the change's steps read it as an example.`);
+      return 0;
+    } catch (e) {
+      if (e instanceof AttachError) {
+        io.err(e.message);
+        return 1;
+      }
+      throw e;
+    }
+  }
+  if (change && o.promote) {
+    if (paths.length) {
+      io.err("--promote names one file already attached; attach new files without it, for example: atticus change attach add-refund-window --promote inputs/refund-rules.pdf");
+      return 2;
+    }
+    try {
+      const r2 = await promoteChangeInput(root, change, o.promote);
+      if (o.json)
+        io.out(JSON.stringify(r2, null, 2));
+      else
+        io.out(r2.note);
+      return 0;
+    } catch (e) {
+      if (e instanceof AttachError) {
+        io.err(e.message);
+        return 1;
+      }
+      throw e;
+    }
+  }
+  if (!change || paths.length === 0) {
+    io.err("Usage: atticus change attach <change> <files...>, for example: atticus change attach add-refund-window refund-rules.pdf");
+    return 2;
+  }
+  if (o.replaces && paths.length !== 1) {
+    io.err("--replaces names the one attached file that the file given replaces: attach one file with it, for example: atticus change attach add-refund-window refund-rules-v2.pdf --replaces inputs/refund-rules-v1.pdf");
+    return 2;
+  }
+  const files = [];
+  let problems = false;
+  for (const p of paths) {
+    try {
+      files.push({ name: basename(p), bytes: new Uint8Array(await readFile(resolve(p))) });
+    } catch {
+      io.err(`Can't read ${p}.`);
+      problems = true;
+    }
+  }
+  let r;
+  try {
+    r = await attachFiles(root, change, files, o.by, o.now, o.replaces);
+  } catch (e) {
+    if (e instanceof AttachError) {
+      io.err(e.message);
+      return 1;
+    }
+    throw e;
+  }
+  if (o.json) {
+    io.out(JSON.stringify(r, null, 2));
+    return r.refused.length || problems ? 1 : 0;
+  }
+  const rel = `${changesRelOf(root)}/${change}`;
+  for (const a of r.added)
+    io.out(attachedLine(rel, a));
+  for (const x of r.refused)
+    io.err(`${x.name}: not attached. ${x.why}`);
+  for (const n of r.notes)
+    io.out(n);
+  if (r.added.length)
+    io.out(`The change's steps read them as data, citing each by file and line or page: atticus next says which step is next. Commit ${rel}/inputs/ with the change.`);
+  return r.refused.length || problems ? 1 : 0;
+}
+async function taskContextCli(root, change, task, o, io) {
+  if (!change || !task) {
+    io.err("Usage: atticus task context <change> <task> [--json|--markdown], for example: atticus task context add-refund-window 1.2");
+    return 2;
+  }
+  try {
+    const command = `atticus task context ${change} ${task}`;
+    const c = await taskContext(root, change, task, {
+      ask: { command, rerun: command, at: (o.now ?? /* @__PURE__ */ new Date()).toISOString() }
+    });
+    io.out(o.json && !o.markdown ? JSON.stringify(c, null, 2) : renderTaskContext(c).trimEnd());
+    return 0;
+  } catch (e) {
+    if (e instanceof Error && ["PlannerError", "ChangeError", "ChangeFileError"].includes(e.name)) {
+      io.err(e.message);
+      return 1;
+    }
+    throw e;
+  }
+}
+export {
+  AttachError,
+  attachFiles,
+  attachedLine,
+  changeAttachCli,
+  promoteChangeInput,
+  taskContextCli
+};

package/dist/chunk-YFSSNGLR.js

@@ -0,0 +1,277 @@
+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 {
+  claimOf,
+  factLabel
+} from "./chunk-NPCD54I7.js";
+import {
+  verifyInputsOf
+} from "./chunk-3GTZ2OON.js";
+import "./chunk-HHUFVJF7.js";
+import {
+  repoContractsOf
+} from "./chunk-GXJVY6WT.js";
+import "./chunk-HE4ZQXZM.js";
+import {
+  checkoutOf
+} from "./chunk-B3O52AUQ.js";
+import "./chunk-XKS6THI5.js";
+import "./chunk-47QE246J.js";
+import "./chunk-XQ3YIV5R.js";
+import "./chunk-MGVYVW7Q.js";
+import "./chunk-NGPU2ARF.js";
+import "./chunk-AY2IUF4K.js";
+import "./chunk-6JLPXDWN.js";
+import {
+  dirSource,
+  repairFormSlips,
+  verifyFacts
+} from "./chunk-4GZXS6S2.js";
+import "./chunk-R4TBNKKC.js";
+import "./chunk-NIXVDQVO.js";
+import "./chunk-UR7RMZ3R.js";
+import "./chunk-N4QZJJVB.js";
+import "./chunk-7F2RUWPU.js";
+import "./chunk-PGKHJYOB.js";
+import "./chunk-MKRBG5EF.js";
+import "./chunk-5XDNUJ4P.js";
+import {
+  factsDirOf,
+  factsRelOf,
+  headFromFiles,
+  layoutOf,
+  loadOrgPack,
+  mapDirOf,
+  mapRelOf,
+  orgPackDirOf,
+  parseFactsLines,
+  questionsRelOf,
+  recordPath,
+  require_dist,
+  specRelOf,
+  stackHelpersOff
+} from "./chunk-577AJVRS.js";
+import "./chunk-D3PO4DOZ.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/verify-preview.js
+import { readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+var import_yaml = __toESM(require_dist(), 1);
+var sameCommit = (a, b) => a.startsWith(b) || b.startsWith(a);
+var slugPart = (s) => s.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
+function prCommand(host, branch) {
+  switch (host) {
+    case "github":
+      return `gh pr create --fill --head ${branch}`;
+    case "gitlab":
+      return `glab mr create --fill --source-branch ${branch}`;
+    case "azure-repos":
+      return `az repos pr create --source-branch ${branch}`;
+    default:
+      return void 0;
+  }
+}
+function editedFields(was, now) {
+  const a = { ...claimOf(was), line: String(was.cite.line) };
+  const b = { ...claimOf(now), line: String(now.cite.line) };
+  return [.../* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)])].sort().filter((k) => a[k] !== b[k]).map((k) => ({
+    name: k,
+    ...a[k] !== void 0 ? { was: a[k] } : {},
+    ...b[k] !== void 0 ? { now: b[k] } : {}
+  }));
+}
+function stepsOf(root, repo, o) {
+  const branch = `correct/${slugPart(repo)}${o.fact ? `-${slugPart(o.fact)}` : ""}`;
+  const message = o.fact ? `${repo}: a person's correction of ${o.fact}, applied by atticus verify --write` : `${repo}: a person's corrections, applied by atticus verify --write`;
+  const pr = prCommand(o.host, branch);
+  return {
+    branch,
+    steps: [
+      { step: "verify", command: `atticus verify ${repo} --write` },
+      { step: "branch", command: `git switch -c ${branch}` },
+      { step: "add", command: `git add ${o.files.join(" ")}` },
+      { step: "commit", command: `git commit -m "${message}"` },
+      { step: "push", command: `git push -u origin ${branch}` },
+      { step: "pr", ...pr ? { command: pr } : {} }
+    ]
+  };
+}
+var linkView = (l) => ({
+  id: l.id,
+  from: l.from,
+  to: l.to,
+  ...l.method ? { method: l.method } : {},
+  path: l.path,
+  confidence: l.confidence,
+  ...l.how ? { how: l.how } : {},
+  ...l.flags?.length ? { flags: [...l.flags] } : {},
+  ...l.was ? { was: l.was } : {}
+});
+async function verifyWritePreview(root, repo, o = {}) {
+  const rel = factsRelOf(root);
+  const wrote = `${rel}/${repo}.corrections.jsonl`;
+  const text = await readFile(join(factsDirOf(root), `${repo}.jsonl`), "utf8").catch(() => void 0);
+  if (text === void 0)
+    return void 0;
+  const op = await loadOrgPack(orgPackDirOf(root)).catch(() => void 0);
+  const host = op?.runtime.adapters.gitHost?.type;
+  const base = [wrote, `${rel}/${repo}.jsonl`, `${rel}/${repo}.verify.yaml`];
+  const plain = (files2, unavailable) => ({
+    repo,
+    wrote,
+    ...stepsOf(root, repo, { ...o, ...host ? { host } : {}, files: files2 }),
+    ...unavailable ? { unavailable } : {}
+  });
+  const read = parseFactsLines(text);
+  const repaired = repairFormSlips(read.facts, read.bad);
+  if (!repaired.facts.length)
+    return plain(base, "unreadable-facts");
+  const before = repaired.facts;
+  const dir = await checkoutOf(root, repo);
+  if (!dir || !existsSync(dir))
+    return plain(base, "no-checkout");
+  const commit = [...new Set(before.map((f) => f.commit))].sort()[0];
+  const head = await headFromFiles(dir);
+  const off = stackHelpersOff();
+  const inputs = await verifyInputsOf(root, repo);
+  const report = await verifyFacts({
+    facts: before,
+    source: dirSource(dir),
+    ...off.has("derived-names") ? { derivedNames: false } : {},
+    ...off.has("readers") ? { readers: false } : {},
+    exclude: inputs.exclude,
+    corrections: inputs.corrections.corrections,
+    reviewed: inputs.reviewed.entries,
+    ...inputs.estate ? { estate: inputs.estate } : {},
+    conventions: inputs.conventions
+  });
+  const kept = new Map(report.accepted.map((f) => [f.id, f]));
+  const wrong = new Set(report.corrections.applied.filter((a) => a.action === "wrong").map((a) => a.fact));
+  const rejected = new Map(report.rejected.map((r) => [r.fact.id, r]));
+  const facts = {
+    dropped: before.filter((f) => !kept.has(f.id)).map((f) => ({
+      id: f.id,
+      kind: f.kind,
+      label: factLabel(f),
+      why: wrong.has(f.id) ? "wrong" : "rejected",
+      ...!wrong.has(f.id) && rejected.get(f.id) ? { message: rejected.get(f.id).message } : {}
+    })),
+    edited: before.flatMap((f) => {
+      const now = kept.get(f.id);
+      const fields = now ? editedFields(f, now) : [];
+      return now && fields.length ? [{ id: f.id, kind: f.kind, label: factLabel(now), fields }] : [];
+    }),
+    kept: report.accepted.length
+  };
+  const staleCorrections = [
+    ...new Set(report.corrections.stale.filter((s) => s.why === "none").map((s) => s.correction.fact))
+  ].sort();
+  const headMoved = head && commit && !sameCommit(head, commit) ? { head: head.slice(0, 12), commit } : void 0;
+  const files = [...base];
+  if (report.rejected.length || existsSync(join(factsDirOf(root), `${repo}.rejected.jsonl`)))
+    files.push(`${rel}/${repo}.rejected.jsonl`);
+  if (report.rejected.length) {
+    return {
+      ...plain(files),
+      preview: {
+        facts,
+        blocked: { rejected: report.rejected.length },
+        ...headMoved ? { headMoved } : {},
+        staleCorrections
+      }
+    };
+  }
+  const { projectFactsIntoCatalog } = await import("./chunk-KM2FBM3T.js");
+  const contracts = await repoContractsOf(root, repo, dir, report.accepted);
+  const companion = join(factsDirOf(root), `${repo}.contracts.yaml`);
+  const onDisk = await readFile(companion, "utf8").catch(() => void 0);
+  const next = contracts.entries.length ? (0, import_yaml.stringify)(contracts, { lineWidth: 0 }) : void 0;
+  if (onDisk !== next)
+    files.push(`${rel}/${repo}.contracts.yaml`);
+  const p = await projectFactsIntoCatalog(root, repo, report.accepted, {
+    ...op ? { op } : {},
+    contracts,
+    cache: false
+  });
+  const catalogRel = layoutOf(root).catalog.replace(/\/+$/, "");
+  const recordFiles = [
+    ...p.diff.added,
+    ...p.diff.changed,
+    ...p.diff.removed,
+    ...p.diff.evidenceOnly
+  ].map((r) => `${catalogRel}/generated/${recordPath(r)}`).sort();
+  files.push(...new Set(recordFiles));
+  if (p.result.flows.length || existsSync(join(root, ...specRelOf(root, repo).split("/"))))
+    files.push(specRelOf(root, repo));
+  if (existsSync(join(mapDirOf(root), repo)) || p.result.records.some((r) => r.kind === "Component"))
+    files.push(`${mapRelOf(root)}/${repo}`);
+  if (existsSync(join(root, ...questionsRelOf(root).split("/"))))
+    files.push(questionsRelOf(root));
+  const key = (l) => `${l.from}|${l.method ?? ""}|${l.path}`;
+  const added = p.links.added.map(linkView);
+  const removed = p.links.removed.map(linkView);
+  const ifaces = (rs) => rs.filter((r) => r.kind === "Interface");
+  const callerHere = (r) => r.evidence.some((e) => e.repo === repo && e.side !== "callee");
+  const after = new Map(ifaces(p.result.records).map((r) => [r.id, r]));
+  const moved = [];
+  for (const a of added) {
+    const old = ifaces(p.existing).find((r) => r.to !== a.to && callerHere(r) && key({ from: r.from, method: r.method, path: r.normalizedPath }) === key(a) && !(after.get(r.id) && callerHere(after.get(r.id))));
+    if (old)
+      moved.push({
+        from: a.from,
+        ...a.method ? { method: a.method } : {},
+        path: a.path,
+        was: old.to,
+        to: a.to
+      });
+  }
+  const movedIds = /* @__PURE__ */ new Set();
+  for (const m of moved) {
+    const old = ifaces(p.existing).find((r) => r.to === m.was && key({ from: r.from, method: r.method, path: r.normalizedPath }) === key(m));
+    if (old)
+      movedIds.add(old.id);
+  }
+  const unmade = ifaces(p.existing).filter((r) => callerHere(r) && after.has(r.id) && !callerHere(after.get(r.id))).filter((r) => !movedIds.has(r.id)).map((r) => ({
+    id: r.id,
+    from: r.from,
+    to: r.to,
+    ...r.method ? { method: r.method } : {},
+    path: r.normalizedPath,
+    confidence: after.get(r.id).confidence,
+    ...r.flags?.length ? { flags: [...r.flags] } : {}
+  })).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+  const movedKeys = new Set(moved.map((m) => `${m.from}|${m.method ?? ""}|${m.path}`));
+  return {
+    ...plain(files),
+    preview: {
+      facts,
+      catalog: {
+        added: p.diff.added.length,
+        changed: p.diff.changed.length,
+        removed: p.diff.removed.length,
+        evidenceOnly: p.diff.evidenceOnly.length,
+        files: [...new Set(recordFiles)]
+      },
+      links: {
+        added: added.filter((l) => !movedKeys.has(key(l))),
+        removed: removed.filter((l) => !movedKeys.has(key(l))),
+        changed: p.links.changed.map(linkView),
+        unmade,
+        moved
+      },
+      ...headMoved ? { headMoved } : {},
+      staleCorrections
+    }
+  };
+}
+export {
+  prCommand,
+  verifyWritePreview
+};

package/dist/chunk-YGKYFMSL.js

@@ -0,0 +1,60 @@
+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 {
+  DEFAULT_IGNORES,
+  DEFAULT_PARSE_CACHE_LIMITS,
+  PLUGIN_EXTRACTOR_PREFIX,
+  PluginRunError,
+  RepoReadError,
+  cacheKeyHash,
+  configHash,
+  createParseCache,
+  deepFreeze,
+  defineExtractor,
+  fsRepo,
+  fsScanCache,
+  globToRegExp,
+  memoryRepo,
+  memoryScanCache,
+  pluginEntryHash,
+  readPinnedEntry,
+  runExtractor,
+  runTranslator,
+  sandboxedExtractor,
+  scanRepo,
+  stampEvidence,
+  tooLargeMessage,
+  withParseCache
+} from "./chunk-MKRBG5EF.js";
+import "./chunk-577AJVRS.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+export {
+  DEFAULT_IGNORES,
+  DEFAULT_PARSE_CACHE_LIMITS,
+  PLUGIN_EXTRACTOR_PREFIX,
+  PluginRunError,
+  RepoReadError,
+  cacheKeyHash,
+  configHash,
+  createParseCache,
+  deepFreeze,
+  defineExtractor,
+  fsRepo,
+  fsScanCache,
+  globToRegExp,
+  memoryRepo,
+  memoryScanCache,
+  pluginEntryHash,
+  readPinnedEntry,
+  runExtractor,
+  runTranslator,
+  sandboxedExtractor,
+  scanRepo,
+  stampEvidence,
+  tooLargeMessage,
+  withParseCache
+};