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

package/dist/chunk-XUPVB7TL.js

@@ -0,0 +1,207 @@
+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 {
+  repoFor
+} from "./chunk-CMV7TGU6.js";
+import {
+  frameworkFacts,
+  insideRepo,
+  parseReviewed
+} from "./chunk-PAMPPUR6.js";
+import {
+  changesSince,
+  createGit
+} from "./chunk-KJPMEAI4.js";
+import {
+  QuestionDraft,
+  factsDirOf,
+  isAdopted,
+  isSecretPath,
+  orgPackDirOf,
+  parseCorrections,
+  raiseQuestions,
+  require_dist,
+  serializeFacts
+} from "./chunk-S2A7YC3Q.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/facts-files.js
+var import_yaml = __toESM(require_dist(), 1);
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+async function checkoutOf(root, repo, dir) {
+  return dir ?? (isAdopted(root) ? root : (await repoFor(root, repo))?.dir ?? void 0);
+}
+async function headOf(dir) {
+  try {
+    const r = await createGit({ timeoutMs: 3e4 })(["rev-parse", "HEAD"], dir);
+    return r.stdout.trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function carryOf(dir, facts, commit, git) {
+  if (!commit)
+    return { carry: {}, missing: [] };
+  const r = await changesSince(dir, facts.map((f) => f.commit), commit, git);
+  return { carry: r.changes, missing: r.missing };
+}
+async function excludesOf(root, repo) {
+  const file = join(orgPackDirOf(root), "scan", `${repo}.yaml`);
+  if (!existsSync(file))
+    return [];
+  try {
+    const doc = (0, import_yaml.parse)(await readFile(file, "utf8"));
+    return (doc?.exclude ?? []).map((e) => e.path).filter((p) => !!p);
+  } catch {
+    return [];
+  }
+}
+async function raiseReadQuestions(root, repo, lines, source, by) {
+  const drafts = [];
+  const problems = [];
+  for (const raw of lines) {
+    const line = JSON.stringify(raw);
+    const r2 = QuestionDraft.safeParse(raw);
+    if (!r2.success) {
+      problems.push({
+        line,
+        message: `not a question: ${r2.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ")}`
+      });
+      continue;
+    }
+    const bad = r2.data.evidence.find((e) => {
+      const file = e.slice(0, e.lastIndexOf(":"));
+      const n = Number(e.slice(e.lastIndexOf(":") + 1));
+      if (!insideRepo(file) || isSecretPath(file))
+        return true;
+      const text = source.read(file);
+      return text === void 0 || n < 1 || n > text.split(/\r?\n/).length;
+    });
+    if (bad) {
+      problems.push({ line, message: `its evidence ${bad} is no line of the repo` });
+      continue;
+    }
+    drafts.push(r2.data);
+  }
+  if (!drafts.length)
+    return { raised: [], known: [], problems };
+  const r = await raiseQuestions(root, drafts, {
+    step: "map",
+    repo,
+    command: by.command,
+    rerun: `atticus map ${repo}`,
+    ...by.run ? { run: by.run } : {},
+    at: by.at
+  });
+  return { raised: r.raised, known: [...r.known, ...r.reused], problems };
+}
+async function writeVerifyFiles(root, repo, report, commit, questionProblems = [], badLines = [], reviewedProblems = []) {
+  const dir = factsDirOf(root);
+  await mkdir(dir, { recursive: true });
+  await writeFile(join(dir, `${repo}.jsonl`), serializeFacts(report.accepted), "utf8");
+  const rejectedFile = join(dir, `${repo}.rejected.jsonl`);
+  const lines = [
+    ...report.rejected.map((r) => JSON.stringify({ code: r.code, message: r.message, fact: r.fact })),
+    ...questionProblems.map((q) => JSON.stringify({ code: "bad-question", message: q.message, question: JSON.parse(q.line) })),
+    ...badLines.map((b) => JSON.stringify({ code: "schema", message: b.message, raw: b.raw })),
+    ...reviewedProblems.map((r) => JSON.stringify({ code: "bad-reviewed", message: r.message, reviewed: r.raw }))
+  ];
+  if (lines.length)
+    await writeFile(rejectedFile, lines.join("\n") + "\n", "utf8");
+  else
+    await rm(rejectedFile, { force: true });
+  const summary = {
+    repo,
+    ...commit ? { commit } : {},
+    accepted: report.accepted.length,
+    rejected: report.rejected.length,
+    redacted: report.redacted,
+    ...report.quotesDropped ? { quotesDropped: report.quotesDropped } : {},
+    coverage: {
+      ratio: report.coverage.ratio,
+      read: report.coverage.read.length,
+      ...report.coverage.reviewed.length ? { reviewed: report.coverage.reviewed.length } : {},
+      unknown: report.coverage.unknown,
+      excluded: report.coverage.excluded
+    },
+    rejections: report.rejected.map((r) => ({ id: r.fact.id, code: r.code, message: r.message })),
+    // ADR 0124 addendum D-app: a person's corrections, said only when there are some.
+    ...report.corrections.applied.length || report.corrections.stale.length ? {
+      corrections: {
+        applied: report.corrections.applied,
+        stale: report.corrections.stale.map((s) => ({
+          fact: s.correction.fact,
+          why: s.why,
+          message: s.message
+        }))
+      }
+    } : {}
+  };
+  if (report.carried.length) {
+    const by = /* @__PURE__ */ new Map();
+    for (const c of report.carried)
+      by.set(c.from, [...by.get(c.from) ?? [], c.id]);
+    summary.carried = [...by.entries()].sort((a, b) => a[0] < b[0] ? -1 : 1).map(([from, facts]) => ({ from, facts: facts.sort() }));
+  }
+  if (report.entriesNoFlowFollows.length)
+    summary.entriesNoFlowFollows = report.entriesNoFlowFollows;
+  if (report.reviewed.length)
+    summary.reviewed = report.reviewed;
+  if (report.authUncited.length)
+    summary.authUncited = report.authUncited;
+  const fws = frameworkFacts(report.accepted);
+  if (fws.length)
+    summary.frameworks = fws.map((f) => ({
+      name: f.name,
+      ...f.version ? { version: f.version } : {},
+      cite: `${f.cite.file}:${f.cite.line}`,
+      ...f.component ? { component: f.component } : {}
+    }));
+  if (report.frameworkGaps.length)
+    summary.frameworkGaps = report.frameworkGaps;
+  await writeFile(join(dir, `${repo}.verify.yaml`), (0, import_yaml.stringify)(summary), "utf8");
+  return summary;
+}
+async function readCorrections(root, repo) {
+  const text = await readFile(join(factsDirOf(root), `${repo}.corrections.jsonl`), "utf8").catch(() => void 0);
+  return text === void 0 ? { corrections: [], bad: [] } : parseCorrections(text);
+}
+async function readReviewed(root, repo) {
+  const text = await readFile(join(factsDirOf(root), `${repo}.reviewed.jsonl`), "utf8").catch(() => void 0);
+  if (text === void 0)
+    return { entries: [], bad: [] };
+  const r = parseReviewed(text);
+  return {
+    entries: r.entries,
+    bad: r.bad.map((b) => ({ line: b.line, raw: b.raw, message: b.message }))
+  };
+}
+function reviewedProblemsOf(bad, report) {
+  return [
+    ...bad,
+    ...report.reviewedProblems.map((p) => ({
+      ...p.line !== void 0 ? { line: p.line } : {},
+      raw: { path: p.path, why: p.why },
+      message: p.message
+    }))
+  ].sort((a, b) => (a.line ?? 0) - (b.line ?? 0));
+}
+
+export {
+  checkoutOf,
+  headOf,
+  carryOf,
+  excludesOf,
+  raiseReadQuestions,
+  writeVerifyFiles,
+  readCorrections,
+  readReviewed,
+  reviewedProblemsOf
+};

package/dist/chunk-XZRON6IV.js

@@ -0,0 +1,131 @@
+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-TV45EUGM.js";
+
+// packages/cli/dist/waiting-commands.js
+var CLOSED = /* @__PURE__ */ new Set(["released", "archived", "closed"]);
+async function readWaiting(run, o) {
+  const problems = [];
+  const json = async (argv, fallback) => {
+    const r = await run(argv);
+    try {
+      return JSON.parse(r.out);
+    } catch {
+      problems.push(`atticus ${argv.join(" ")}: ${r.err.trim().split("\n")[0] || "no answer"}`);
+      return fallback;
+    }
+  };
+  const questions = (await json(["questions", "list", "--state", "open", "--json"], {})).questions ?? [];
+  const needs = (await json(["needs", "--all", "--json"], [])).filter((n) => (n.status ?? "open") === "open");
+  const steps = (await json(["todo", "--json"], [])).filter((s) => (s.state ?? "open") === "open");
+  const changes = (await json(["change", "list", "--json"], [])).filter((c) => !CLOSED.has(c.state));
+  const findings = /* @__PURE__ */ new Map();
+  for (const c of changes)
+    findings.set(c.id, (await json(["findings", c.id, "--json"], [])).filter((f) => (f.state ?? "open") === "open"));
+  const unverified = await json(["knowledge", "list", "--unverified", "--json"], []);
+  const words = o.filter?.trim().toLowerCase();
+  const hit = (...fields) => !words || fields.some((f) => f !== void 0 && f.toLowerCase().includes(words));
+  const byChange = [];
+  for (const c of changes) {
+    const whole = hit(c.id, c.title);
+    const w = {
+      change: c.id,
+      title: c.title,
+      state: c.state,
+      needs: needs.filter((n) => n.change === c.id && (whole || hit(n.item, n.title, n.kind, n.handledBy))),
+      findings: (findings.get(c.id) ?? []).filter((f) => whole || hit(f.id, f.summary, f.severity)),
+      manualSteps: steps.filter((s) => s.change === c.id && (whole || hit(s.id, s.title, s.where)))
+    };
+    if (w.needs.length + w.findings.length + w.manualSteps.length)
+      byChange.push(w);
+  }
+  const blocking = (w) => w.findings.some((f) => f.severity === "blocking");
+  byChange.sort((a, b) => Number(blocking(b)) - Number(blocking(a)) || a.title.localeCompare(b.title));
+  const known = new Set(changes.map((c) => c.id));
+  const other = {
+    questions: questions.filter((q) => hit(q.id, q.repo, q.question)),
+    manualSteps: steps.filter((s) => (!s.change || !known.has(s.change)) && hit(s.id, s.title, s.where, s.change)),
+    knowledgeToVerify: words ? 0 : unverified.length
+  };
+  const sum = (f) => byChange.reduce((n, w) => n + f(w), 0);
+  return {
+    changes: byChange,
+    other,
+    counts: {
+      questions: other.questions.length,
+      needs: sum((w) => w.needs.length),
+      manualSteps: sum((w) => w.manualSteps.length) + other.manualSteps.length,
+      findings: sum((w) => w.findings.length),
+      knowledgeToVerify: other.knowledgeToVerify
+    },
+    problems
+  };
+}
+var plural = (n, w) => `${n} ${w}${n === 1 ? "" : "s"}`;
+var stepId = (s) => s.change ? `${s.change}/${s.id}` : s.id;
+function byChangeLines(w) {
+  const out = [];
+  for (const c of w.changes) {
+    const parts = [
+      c.needs.length && plural(c.needs.length, "need"),
+      c.findings.length && plural(c.findings.length, "finding"),
+      c.manualSteps.length && plural(c.manualSteps.length, "manual step")
+    ].filter(Boolean);
+    out.push(`${c.title} (${c.change}): ${parts.join(", ")}`);
+    for (const n of c.needs)
+      out.push(`  need     ${n.item}: ${n.title}`);
+    for (const f of c.findings)
+      out.push(`  finding  ${f.id} (${f.severity}): ${f.summary}`);
+    for (const s of c.manualSteps)
+      out.push(`  step     ${stepId(s)}: ${s.title}`);
+  }
+  const o = w.other;
+  if (o.questions.length || o.manualSteps.length || o.knowledgeToVerify) {
+    out.push("Not tied to a change:");
+    for (const q of o.questions)
+      out.push(`  question ${q.id} (${q.repo}): ${q.question}`);
+    for (const s of o.manualSteps)
+      out.push(`  step     ${stepId(s)}: ${s.title}`);
+    if (o.knowledgeToVerify)
+      out.push(`  ${plural(o.knowledgeToVerify, "knowledge item")} no one has verified: atticus knowledge list --unverified`);
+  }
+  return out;
+}
+function byKindLines(w) {
+  const out = [];
+  const group = (title, lines) => {
+    if (lines.length)
+      out.push(`${title} (${lines.length})`, ...lines.map((l) => `  ${l}`));
+  };
+  group("Questions", w.other.questions.map((q) => `${q.id} (${q.repo}): ${q.question}`));
+  group("Needs", w.changes.flatMap((c) => c.needs.map((n) => `${n.item} (${c.change}): ${n.title}`)));
+  group("Manual steps", [...w.changes.flatMap((c) => c.manualSteps), ...w.other.manualSteps].map((s) => `${stepId(s)}: ${s.title}`));
+  group("Findings", w.changes.flatMap((c) => c.findings.map((f) => `${f.id} (${c.change}, ${f.severity}): ${f.summary}`)));
+  if (w.other.knowledgeToVerify)
+    out.push(`Knowledge to verify (${w.other.knowledgeToVerify}): atticus knowledge list --unverified`);
+  return out;
+}
+async function waitingCli(o, io, run) {
+  const by = o.by ?? "change";
+  const w = await readWaiting(run, o.filter ? { filter: o.filter } : {});
+  if (o.json) {
+    io.out(JSON.stringify({ by, ...w }, null, 2));
+    return 0;
+  }
+  const lines = by === "kind" ? byKindLines(w) : byChangeLines(w);
+  if (!lines.length)
+    io.out(o.filter ? `Nothing waits on you that matches "${o.filter}".` : "Nothing waits on you.");
+  else
+    for (const l of lines)
+      io.out(l);
+  for (const p of w.problems)
+    io.err(`Couldn't read ${p}`);
+  return 0;
+}
+export {
+  readWaiting,
+  waitingCli
+};

package/dist/chunk-Y4NG2FP5.js

@@ -0,0 +1,94 @@
+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 {
+  BuildAttempt,
+  CONFORM_DIR,
+  CONFORM_GATE,
+  ConformError,
+  FILE_FORMAT,
+  RunLevel,
+  TASK_RUNNER,
+  TaskRunError,
+  TaskRunRecord,
+  TaskRunState,
+  applyChanges,
+  completeTaskHandoff,
+  conformAfterBuild,
+  conformChange,
+  conformFindingId,
+  conformFindings,
+  conformScanDir,
+  conformanceOf,
+  findWaitingTaskRun,
+  isTaskRun,
+  parseAnswer,
+  readConformResults,
+  readTaskRun,
+  refusedPath,
+  runTask,
+  saveRunSummary,
+  saveTaskRun,
+  shellCommandRunner,
+  taskDir,
+  taskPack,
+  taskRunnerAgent
+} from "./chunk-CEZQOLEO.js";
+import "./chunk-6SCVQZX5.js";
+import "./chunk-65NYPGRC.js";
+import "./chunk-RCU3MPY2.js";
+import "./chunk-V5PKHHQQ.js";
+import "./chunk-VPTTCYOC.js";
+import "./chunk-L6SGQIR3.js";
+import "./chunk-7UFQZXZA.js";
+import "./chunk-56YQ6ROQ.js";
+import "./chunk-4AK7IBVP.js";
+import "./chunk-7JUKDRSZ.js";
+import "./chunk-OLWFG75W.js";
+import "./chunk-L24C55VN.js";
+import "./chunk-PAMPPUR6.js";
+import "./chunk-23W7VWKR.js";
+import "./chunk-7EKXJZ2Y.js";
+import "./chunk-MC3H7736.js";
+import "./chunk-T6AIP7H5.js";
+import "./chunk-KJPMEAI4.js";
+import "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+export {
+  BuildAttempt,
+  CONFORM_DIR,
+  CONFORM_GATE,
+  ConformError,
+  FILE_FORMAT,
+  RunLevel,
+  TASK_RUNNER,
+  TaskRunError,
+  TaskRunRecord,
+  TaskRunState,
+  applyChanges,
+  completeTaskHandoff,
+  conformAfterBuild,
+  conformChange,
+  conformFindingId,
+  conformFindings,
+  conformScanDir,
+  conformanceOf,
+  findWaitingTaskRun,
+  isTaskRun,
+  parseAnswer,
+  readConformResults,
+  readTaskRun,
+  refusedPath,
+  runTask,
+  saveRunSummary,
+  saveTaskRun,
+  shellCommandRunner,
+  taskDir,
+  taskPack,
+  taskRunnerAgent
+};