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

package/dist/chunk-NNUASOAA.js

@@ -0,0 +1,34 @@
+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 {
+  addToInbox,
+  intakeAdd,
+  intakeContext,
+  intakeList,
+  triageDecide,
+  triageList
+} from "./chunk-WARBF2KY.js";
+import "./chunk-VOGCSYOI.js";
+import "./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-PGKHJYOB.js";
+import "./chunk-MKRBG5EF.js";
+import "./chunk-5XDNUJ4P.js";
+import "./chunk-577AJVRS.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+export {
+  addToInbox,
+  intakeAdd,
+  intakeContext,
+  intakeList,
+  triageDecide,
+  triageList
+};

package/dist/chunk-NPCD54I7.js

@@ -0,0 +1,226 @@
+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 {
+  HttpError,
+  badRequest,
+  notFound
+} from "./chunk-HHUFVJF7.js";
+import {
+  readCorrections
+} from "./chunk-B3O52AUQ.js";
+import {
+  applyCorrections,
+  correctedFact,
+  correctionFor,
+  repairFormSlips
+} from "./chunk-4GZXS6S2.js";
+import {
+  FACT_FIXED_FIELDS,
+  FactCorrection,
+  api_exports,
+  correctionLine,
+  factsDirOf,
+  factsRelOf,
+  listQuestions,
+  parseAuditFile,
+  parseFactsLines,
+  sampleConfirmed
+} from "./chunk-577AJVRS.js";
+
+// packages/cli/dist/ui-api-facts.js
+import { appendFile, mkdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+var REPO = /^[a-z0-9][a-z0-9._-]{0,99}$/i;
+var fixed = new Set(FACT_FIXED_FIELDS);
+function factLabel(f) {
+  switch (f.kind) {
+    case "entry":
+      return `${f.method ? `${f.method} ` : ""}${f.path}`;
+    case "call":
+      return `${f.method ? `${f.method} ` : ""}${f.path}${f.to ? ` \u2192 ${f.to}` : ""}`;
+    case "store":
+      return `${f.name} (${f.op})`;
+    case "field":
+      return `${f.name}${f.type ? `: ${f.type}` : ""}`;
+    case "deploy":
+      return `${f.platform}${f.resourceName ? ` ${f.resourceName}` : ""}`;
+    case "config":
+      return `${f.key}${f.value !== void 0 ? ` = ${f.value}` : ""}`;
+    // ADR 0124 addendum A-framework: what the repo or the module is built on.
+    case "framework":
+      return `${f.name}${f.version ? ` ${f.version}` : ""}`;
+    case "flow":
+      return f.name;
+  }
+}
+function claimOf(f) {
+  const out = {};
+  for (const [k, v] of Object.entries(f))
+    if (!fixed.has(k) && typeof v === "string")
+      out[k] = v;
+  out.value = f.cite.value;
+  return out;
+}
+var spot = (c) => ({
+  file: c.file,
+  line: c.line,
+  value: c.value,
+  ...c.quote ? { quote: c.quote } : {}
+});
+async function readFacts(root, repo) {
+  const file = `${factsRelOf(root)}/${repo}.jsonl`;
+  const text = await readFile(join(factsDirOf(root), `${repo}.jsonl`), "utf8").catch(() => void 0);
+  if (text === void 0)
+    return { file, present: false, facts: [], bad: [] };
+  const read = parseFactsLines(text);
+  const p = repairFormSlips(read.facts, read.bad);
+  return {
+    file,
+    present: true,
+    facts: p.facts,
+    bad: [
+      ...p.slips.map((x) => ({
+        file,
+        message: `slip of form fixed as read (a note; atticus verify ${repo} writes the fix into the facts file): ${x.message}`
+      })),
+      ...p.bad.map((b) => ({
+        file,
+        message: `line ${b.line} isn't a fact: ${b.issues.map((i) => i.message).join("; ")}`
+      }))
+    ]
+  };
+}
+async function repoFactsView(root, repo) {
+  const f = await readFacts(root, repo);
+  const cFile = `${factsRelOf(root)}/${repo}.corrections.jsonl`;
+  const c = await readCorrections(root, repo);
+  const problems = [
+    ...f.bad,
+    ...c.bad.map((b) => ({
+      file: cFile,
+      message: `line ${b.line} isn't a correction: ${b.message}`
+    }))
+  ];
+  const auditText = await readFile(join(factsDirOf(root), `${repo}.audit.yaml`), "utf8").catch(() => void 0);
+  const audit = auditText === void 0 ? void 0 : parseAuditFile(auditText);
+  const sampled = sampleConfirmed(audit?.ok ? audit.file : void 0, f.facts);
+  if (audit && !audit.ok)
+    problems.push({
+      file: `${factsRelOf(root)}/${repo}.audit.yaml`,
+      message: `isn't an audit file: ${audit.issues[0] ?? "invalid"}`
+    });
+  const facts = f.facts.map((x) => {
+    const corr = correctionFor(x, c.corrections);
+    return {
+      id: x.id,
+      kind: x.kind,
+      label: factLabel(x),
+      claim: claimOf(x),
+      cite: spot(x.cite),
+      ...x.kind === "flow" ? {
+        steps: [
+          ...x.steps.map((s) => ({ ...spot(s.cite), what: s.what })),
+          ...x.errors.map((e) => ({ ...spot(e.cite), what: `${e.when} \u2192 ${e.then}` }))
+        ]
+      } : {},
+      verified: x.verified === "line" && sampled.has(x.id) ? "sample" : x.verified,
+      by: x.by,
+      ...corr ? { correction: corr } : {}
+    };
+  });
+  const stale = applyCorrections(f.facts, c.corrections).stale.filter((s) => s.why === "none").map((s) => s.correction.fact);
+  const questions = await listQuestions(root, { repo, state: "open" }).then((l) => l.questions.map((q) => ({ id: q.id, question: q.question, evidence: q.evidence })), () => []);
+  return {
+    repo,
+    file: f.file,
+    present: f.present,
+    ...f.facts[0] ? { commit: f.facts[0].commit } : {},
+    facts,
+    corrections: { file: cFile, count: c.corrections.length, stale: [...new Set(stale)].sort() },
+    questions,
+    verify: `atticus verify ${repo}`,
+    problems
+  };
+}
+var repoOf = (v) => {
+  if (!REPO.test(v))
+    throw badRequest(`${JSON.stringify(v)} isn't a repo name.`);
+  return v;
+};
+function uiFactsRoutes(r, ctx, deps = {}) {
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  return r.add("GET", "/api/facts/{repo}", async ({ params }) => ({
+    status: 200,
+    body: await repoFactsView(ctx.root, repoOf(params.repo))
+  })).add("GET", "/api/facts/{repo}/preview", async ({ params, query }) => {
+    const repo = repoOf(params.repo);
+    const fact = query.get("fact") || void 0;
+    const { verifyWritePreview } = await import("./chunk-YFSSNGLR.js");
+    const v = await verifyWritePreview(ctx.root, repo, fact ? { fact } : {});
+    if (!v)
+      throw notFound(`There are no facts for ${repo} at ${factsRelOf(ctx.root)}/${repo}.jsonl.`);
+    return { status: 200, body: v };
+  }).add("POST", "/api/facts/{repo}/corrections", async ({ params, body }) => {
+    const repo = repoOf(params.repo);
+    const b = api_exports.FactCorrectionRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw badRequest("Say which fact and what is wrong: { fact, action, set, line, reason }.", {
+        errors: b.error.issues.map((i) => ({ path: i.path.join("."), message: i.message }))
+      });
+    const f = await readFacts(ctx.root, repo);
+    if (!f.present)
+      throw notFound(`There are no facts for ${repo} at ${f.file}.`);
+    const fact = f.facts.find((x) => x.id === b.data.fact);
+    if (!fact)
+      throw notFound(`${f.file} has no fact ${b.data.fact}.`);
+    const was = claimOf(fact);
+    const set = Object.fromEntries(Object.entries(b.data.set ?? {}).map(([k, v]) => [k, v.trim()]).filter(([k, v]) => was[k] !== v));
+    const line = b.data.line !== void 0 && b.data.line !== fact.cite.line ? b.data.line : void 0;
+    const c = FactCorrection.safeParse({
+      schemaVersion: 1,
+      fact: fact.id,
+      target: {
+        kind: fact.kind,
+        file: fact.cite.file,
+        line: fact.cite.line,
+        value: fact.cite.value
+      },
+      action: b.data.action,
+      ...b.data.action === "edit" && Object.keys(set).length ? { set } : {},
+      ...b.data.action === "edit" && line !== void 0 ? { line } : {},
+      ...b.data.reason ? { reason: b.data.reason } : {},
+      by: ctx.user,
+      at: now().toISOString()
+    });
+    if (!c.success)
+      throw new HttpError(422, "Atticus can't record that", c.error.issues.map((i) => i.message).join("; "));
+    if (c.data.action === "edit") {
+      const fixedFact = correctedFact(fact, c.data);
+      if (typeof fixedFact === "string")
+        throw new HttpError(422, "That isn't a fact", `The corrected ${fact.kind} isn't one: ${fixedFact}.`);
+    }
+    const rel = `${factsRelOf(ctx.root)}/${repo}.corrections.jsonl`;
+    const written = correctionLine(c.data);
+    await mkdir(factsDirOf(ctx.root), { recursive: true });
+    await appendFile(join(factsDirOf(ctx.root), `${repo}.corrections.jsonl`), `${written}
+`, "utf8");
+    ctx.events.publish({ type: "file.changed", path: rel });
+    const result = {
+      correction: c.data,
+      file: rel,
+      commit: `git add ${rel} && git commit -m "${repo}: a person's correction of ${fact.id}"`,
+      verify: `atticus verify ${repo}`,
+      line: written
+    };
+    return { status: 200, body: result };
+  });
+}
+
+export {
+  factLabel,
+  claimOf,
+  uiFactsRoutes
+};