@maycombhq/atticus 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/chunk-4FOAYLI4.js

@@ -0,0 +1,328 @@
+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 {
+  contractCheckOf
+} from "./chunk-GX74YWR7.js";
+import {
+  readCatalog
+} from "./chunk-4SLBCEPD.js";
+import {
+  frameworkFacts,
+  frameworkGaps
+} from "./chunk-JYMIB5XY.js";
+import {
+  baseClonePath,
+  loadRepos
+} from "./chunk-XOL3GFW2.js";
+import {
+  auditItemHolds,
+  auditPrecision,
+  catalogDirOf,
+  factsDirOf,
+  factsFileOf,
+  factsRelOf,
+  headFromFiles,
+  isAdopted,
+  listQuestions,
+  parseAuditFile,
+  parseFacts,
+  require_dist
+} from "./chunk-PAINMSID.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/ui-api-trust.js
+var import_yaml = __toESM(require_dist(), 1);
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+function rejectedLines(text2) {
+  const out = [];
+  for (const raw of (text2 ?? "").split(/\r?\n/)) {
+    if (!raw.trim())
+      continue;
+    let l;
+    try {
+      l = JSON.parse(raw);
+    } catch {
+      out.push({ code: "unreadable", message: raw.slice(0, 200) });
+      continue;
+    }
+    const f = l.fact && typeof l.fact === "object" ? l.fact : void 0;
+    const cite = f?.cite;
+    out.push({
+      ...typeof f?.id === "string" ? { fact: f.id } : {},
+      ...typeof f?.kind === "string" ? { kind: f.kind } : {},
+      ...typeof cite?.file === "string" ? { file: cite.file } : {},
+      ...typeof cite?.line === "number" && Number.isInteger(cite.line) ? { line: cite.line } : {},
+      code: typeof l.code === "string" ? l.code : "rejected",
+      message: typeof l.message === "string" ? l.message : ""
+    });
+  }
+  return out;
+}
+var SHA = /^[0-9a-f]{7,64}$/;
+var FACT_BY = /* @__PURE__ */ new Set(["assistant", "reader", "person"]);
+var UNKNOWN_SHOWN = 50;
+var firstLine = (e) => String(e.message ?? e).split("\n")[0];
+var text = (p) => readFile(p, "utf8").catch(() => void 0);
+function reportOf(raw) {
+  const r = raw;
+  if (!r || typeof r.accepted !== "number" || typeof r.rejected !== "number")
+    return "not a verifier's report: accepted and rejected are missing";
+  const list = (v) => Array.isArray(v) ? v.map(String) : [];
+  const unknown = list(r.coverage?.unknown);
+  return {
+    accepted: r.accepted,
+    rejected: r.rejected,
+    redacted: typeof r.redacted === "number" ? r.redacted : 0,
+    coverage: {
+      ratio: typeof r.coverage?.ratio === "number" ? r.coverage.ratio : 0,
+      read: typeof r.coverage?.read === "number" ? r.coverage.read : 0,
+      unknown: unknown.length,
+      excluded: list(r.coverage?.excluded).length
+    },
+    unknownFiles: unknown.slice(0, UNKNOWN_SHOWN),
+    ...typeof r.commit === "string" && SHA.test(r.commit) ? { commit: r.commit } : {}
+  };
+}
+var sameCommit = (a, b) => a && b ? a.startsWith(b) || b.startsWith(a) : null;
+function catalogSources(records) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    const seen = /* @__PURE__ */ new Map();
+    for (const e of r.evidence) {
+      if (!e.repo)
+        continue;
+      const s = seen.get(e.repo) ?? { facts: false, readers: false };
+      if (!e.extractor && e.by && FACT_BY.has(e.by))
+        s.facts = true;
+      else if (e.source !== "manual")
+        s.readers = true;
+      seen.set(e.repo, s);
+    }
+    for (const [repo, s] of seen) {
+      const c = counts.get(repo) ?? { facts: 0, readers: 0 };
+      if (s.facts)
+        c.facts += 1;
+      else if (s.readers)
+        c.readers += 1;
+      counts.set(repo, c);
+    }
+  }
+  return counts;
+}
+function nextOf(repo, r) {
+  const read = { command: `atticus map ${repo}`, slash: `/atticus-map ${repo}` };
+  if (!r.facts.present)
+    return { state: "not-read", next: read };
+  const report = r.verify.report;
+  if (!report)
+    return { state: "unverified", next: { command: `atticus verify ${repo}` } };
+  if (report.rejected > 0)
+    return {
+      state: "rejected",
+      next: { command: `atticus verify ${repo}`, slash: `/atticus-map ${repo}` }
+    };
+  if (r.sameCommit === false)
+    return { state: "stale", next: read };
+  if (r.facts.unverified > 0)
+    return { state: "unverified", next: { command: `atticus verify ${repo}` } };
+  if (r.catalog.fromFacts === 0)
+    return { state: "unwritten", next: { command: `atticus verify ${repo} --write` } };
+  if (report.coverage.unknown > 0)
+    return { state: "unknown-files", next: read };
+  return { state: "trusted" };
+}
+async function trustView(root) {
+  const rel = (p) => relative(root, p).split(sep).join("/") || ".";
+  const problems = [];
+  const dir = factsDirOf(root);
+  const factsRel = factsRelOf(root);
+  const ids = [];
+  try {
+    for (const r of await loadRepos(root))
+      ids.push(r.id);
+  } catch (e) {
+    problems.push({ file: "org-pack/profiles", message: firstLine(e) });
+  }
+  const files = await readdir(dir).catch(() => []);
+  const named = /* @__PURE__ */ new Set();
+  for (const f of files) {
+    const of = factsFileOf(f);
+    if (of && (of.facts || f.endsWith(".verify.yaml")))
+      named.add(of.repo);
+  }
+  for (const id of [...named].sort())
+    if (!ids.includes(id))
+      ids.push(id);
+  const catalog = await readCatalog(join(catalogDirOf(root), "generated"), { cacheRoot: root });
+  for (const p of catalog.problems)
+    problems.push({ file: rel(join(catalogDirOf(root), "generated", p.file)), message: p.message });
+  const counts = catalogSources(catalog.records);
+  const open = await listQuestions(root, { state: "open" }).then((l) => l.questions, () => []);
+  const adopted = isAdopted(root);
+  const repos = [];
+  for (const repo of ids) {
+    const factsPath = join(dir, `${repo}.jsonl`);
+    const raw = await text(factsPath);
+    const facts = {
+      path: rel(factsPath),
+      present: raw !== void 0,
+      count: 0,
+      unverified: 0
+    };
+    let frameworks;
+    let terms;
+    let kept = [];
+    const lists = { rejected: [], excluded: [], asked: [], unverified: [] };
+    if (raw !== void 0 && raw.trim()) {
+      const parsed = parseFacts(raw);
+      if (parsed.ok) {
+        kept = parsed.facts;
+        facts.count = parsed.facts.length;
+        const unchecked = parsed.facts.filter((f) => f.verified === "none");
+        facts.unverified = unchecked.length;
+        lists.unverified = unchecked.slice(0, UNKNOWN_SHOWN).map((f) => ({
+          fact: f.id,
+          kind: f.kind,
+          file: f.cite.file,
+          line: f.cite.line
+        }));
+        const commit = parsed.facts[0]?.commit;
+        if (commit)
+          facts.commit = commit;
+        const gaps = new Map(frameworkGaps(parsed.facts).map((g) => [g.id, g.question]));
+        const built = frameworkFacts(parsed.facts).map((f) => ({
+          name: f.name,
+          ...f.version ? { version: f.version } : {},
+          ...f.component ? { component: f.component } : {},
+          cite: `${f.cite.file}:${f.cite.line}`,
+          ...gaps.has(f.id) ? { gap: gaps.get(f.id) } : {}
+        }));
+        if (built.length)
+          frameworks = built;
+        const t = parsed.facts.flatMap((f) => f.kind === "term" ? [
+          {
+            term: f.term,
+            value: f.value,
+            role: f.role,
+            cite: `${f.cite.file}:${f.cite.line}`,
+            ...f.meaning ? { meaning: `${f.meaning.file}:${f.meaning.line}` } : {},
+            ...f.note !== void 0 ? { note: f.note } : {}
+          }
+        ] : []);
+        if (t.length)
+          terms = t;
+      } else
+        problems.push({
+          file: rel(factsPath),
+          message: `doesn't read as facts: ${parsed.issues[0]?.message ?? "invalid"}`
+        });
+    }
+    const reportPath = join(dir, `${repo}.verify.yaml`);
+    let report = null;
+    let excluded = [];
+    const reportText = await text(reportPath);
+    if (reportText !== void 0) {
+      try {
+        const doc = (0, import_yaml.parse)(reportText);
+        const r = reportOf(doc);
+        if (typeof r === "string")
+          problems.push({ file: rel(reportPath), message: r });
+        else {
+          report = r;
+          const ex = doc?.coverage?.excluded;
+          if (Array.isArray(ex))
+            excluded = ex.map(String).slice(0, UNKNOWN_SHOWN);
+        }
+      } catch (e) {
+        problems.push({ file: rel(reportPath), message: `can't read YAML: ${firstLine(e)}` });
+      }
+    }
+    if (!facts.commit && report?.commit)
+      facts.commit = report.commit;
+    lists.rejected = rejectedLines(await text(join(dir, `${repo}.rejected.jsonl`)));
+    lists.excluded = excluded;
+    lists.asked = open.filter((q) => q.repo === repo).map((q) => ({ id: q.id, question: q.question, lines: q.evidence }));
+    let audit;
+    const auditPath = join(dir, `${repo}.audit.yaml`);
+    const auditText = await text(auditPath);
+    if (auditText !== void 0) {
+      const a = parseAuditFile(auditText);
+      if (!a.ok)
+        problems.push({ file: rel(auditPath), message: `isn't an audit file: ${a.issues[0]}` });
+      else {
+        const byId = new Map(kept.map((f) => [f.id, f]));
+        const p = auditPrecision(a.file.items, (i) => auditItemHolds(i, byId));
+        audit = {
+          path: rel(auditPath),
+          facts: p.facts,
+          byKind: p.byKind,
+          links: p.links,
+          // ADR 0181: the AI's decisions audited apart, when any were drawn.
+          ...p.ai.drawn ? { ai: p.ai } : {}
+        };
+      }
+    }
+    let checkoutDir;
+    try {
+      checkoutDir = adopted ? root : baseClonePath(root, repo);
+    } catch {
+      checkoutDir = void 0;
+    }
+    const head = checkoutDir ? await headFromFiles(checkoutDir) : void 0;
+    const present = checkoutDir ? await stat(join(checkoutDir, ".git")).then(() => true, () => false) : false;
+    const checkout = {
+      path: checkoutDir ? rel(checkoutDir) : `workspace/${repo}`,
+      present,
+      ...head ? { commit: head } : {}
+    };
+    const c = counts.get(repo) ?? { facts: 0, readers: 0 };
+    const from = c.facts && c.readers ? "both" : c.facts ? "facts" : c.readers ? "readers" : "none";
+    const base = {
+      repo,
+      facts,
+      verify: { path: rel(reportPath), report },
+      checkout,
+      sameCommit: sameCommit(report?.commit ?? facts.commit, head),
+      catalog: { from, fromFacts: c.facts, fromReaders: c.readers }
+    };
+    const { state, next } = nextOf(repo, base);
+    repos.push({
+      ...base,
+      state,
+      ...next ? { next } : {},
+      ...frameworks ? { frameworks } : {},
+      ...terms ? { terms } : {},
+      lists,
+      ...audit ? { audit } : {}
+    });
+  }
+  const contracts = await contractCheckOf(root).then((c) => c.result.counts.compared ? c.result.counts : void 0, () => void 0);
+  return { factsDir: factsRel, repos, problems, ...contracts ? { contracts } : {} };
+}
+function uiTrustRoutes(r, ctx) {
+  return r.add("GET", "/api/trust", async () => ({ status: 200, body: await trustView(ctx.root) })).add("GET", "/api/trust/fresh", async () => {
+    const { estateFreshness } = await import("./chunk-D5KV5PSK.js");
+    const v = await estateFreshness(ctx.root);
+    const body = {
+      ...v,
+      repos: v.repos.map(({ rulesLacking: _r, ...r2 }) => {
+        if (r2.state !== "rules-changed")
+          return { ...r2, state: r2.state };
+        const { command: _c, slash: _s, ...x } = r2;
+        return { ...x, state: "fresh" };
+      })
+    };
+    return { status: 200, body };
+  });
+}
+
+export {
+  catalogSources,
+  uiTrustRoutes
+};