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

package/dist/chunk-JMSCMUCA.js

@@ -0,0 +1,271 @@
+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 {
+  carryOf,
+  checkoutOf,
+  excludesOf,
+  headOf,
+  raiseReadQuestions,
+  readCorrections,
+  readReviewed,
+  reviewedProblemsOf,
+  writeVerifyFiles
+} from "./chunk-CR3MTH32.js";
+import "./chunk-O3WI5KWW.js";
+import {
+  dirSource,
+  frameworkFacts,
+  frameworksToLearn,
+  verifyFacts
+} from "./chunk-PAMPPUR6.js";
+import {
+  NoRoomError,
+  roomGuard,
+  streamFacts
+} from "./chunk-EPTBZ3GP.js";
+import "./chunk-EFHQ3TWP.js";
+import "./chunk-GQ4N4WKF.js";
+import {
+  factsDirOf,
+  factsRelOf,
+  listQuestions,
+  loadOrgPack
+} from "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/verify-commands.js
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+async function frameworksKnownTo(root) {
+  const op = await loadOrgPack(root).catch(() => void 0);
+  return (op?.frameworks ?? []).flatMap((f) => [f.name, ...f.artifacts]);
+}
+var SHOWN = 5;
+function questionLines(text) {
+  const lines = [];
+  const problems = [];
+  for (const raw of text.split(/\r?\n/)) {
+    if (!raw.trim())
+      continue;
+    try {
+      lines.push(JSON.parse(raw));
+    } catch (e) {
+      problems.push({
+        line: JSON.stringify(raw),
+        message: `not JSON: ${e.message}`
+      });
+    }
+  }
+  return { lines, problems };
+}
+async function verifyCommand(root, repo, o, io) {
+  const rel = factsRelOf(root);
+  const file = join(factsDirOf(root), `${repo}.jsonl`);
+  if (!existsSync(file)) {
+    io.err(`No facts for ${repo} at ${rel}/${repo}.jsonl. Run /atticus-map ${repo} in your assistant first (or atticus map ${repo} to read it in batches); it writes that file.`);
+    return 2;
+  }
+  const room = roomGuard({
+    what: `${repo}'s facts`,
+    ...o.ceilingBytes !== void 0 ? { ceilingBytes: o.ceilingBytes } : {}
+  });
+  let parsed;
+  try {
+    parsed = await streamFacts(file, room);
+  } catch (e) {
+    if (!(e instanceof NoRoomError))
+      throw e;
+    io.err(`atticus verify ${repo}: ${e.message}`);
+    return 2;
+  }
+  if (!parsed.facts.length && parsed.bad.length) {
+    io.err(`${rel}/${repo}.jsonl does not read as facts:`);
+    for (const b of parsed.bad.slice(0, 20))
+      io.err(`  line ${b.line}: ${b.issues.map((i) => i.message).join("; ")}`);
+    if (parsed.bad.length > 20)
+      io.err(`  ... and ${parsed.bad.length - 20} more (no line of the file is a fact)`);
+    return 2;
+  }
+  const dir = await checkoutOf(root, repo, o.dir);
+  if (!dir) {
+    io.err(`No checkout of ${repo}: clone it (atticus workspace sync) or give its folder with --dir.`);
+    return 2;
+  }
+  const commit = o.commit ?? await headOf(dir);
+  const source = dirSource(dir);
+  const { carry, missing } = await carryOf(dir, parsed.facts, commit, o.git);
+  const corrections = await readCorrections(root, repo);
+  for (const b of corrections.bad.slice(0, SHOWN))
+    io.err(`${rel}/${repo}.corrections.jsonl line ${b.line} isn't a correction: ${b.message}`);
+  if (corrections.bad.length > SHOWN)
+    io.err(`... and ${corrections.bad.length - SHOWN} more lines of ${rel}/${repo}.corrections.jsonl that aren't corrections`);
+  const reviewed = await readReviewed(root, repo);
+  let report;
+  try {
+    report = await verifyFacts({
+      facts: parsed.facts,
+      source,
+      ...commit ? { commit, carry } : {},
+      ...o.routed ? { routed: o.routed } : {},
+      exclude: await excludesOf(root, repo),
+      corrections: corrections.corrections,
+      reviewed: reviewed.entries,
+      room
+    });
+  } catch (e) {
+    if (!(e instanceof NoRoomError))
+      throw e;
+    io.err(`atticus verify ${repo}: ${e.message}`);
+    return 2;
+  }
+  const reviewedBad = reviewedProblemsOf(reviewed.bad, report).map((p) => ({
+    ...p,
+    message: `${rel}/${repo}.reviewed.jsonl ${p.message}`
+  }));
+  const qFile = join(factsDirOf(root), `${repo}.questions.jsonl`);
+  let raised = 0;
+  let known = 0;
+  let qLines = 0;
+  const qProblems = [];
+  const hasQuestions = existsSync(qFile);
+  if (hasQuestions) {
+    const q = questionLines(await readFile(qFile, "utf8"));
+    qLines = q.lines.length + q.problems.length;
+    qProblems.push(...q.problems);
+    const r = await raiseReadQuestions(root, repo, q.lines, source, {
+      command: `atticus verify ${repo}`,
+      at: (o.now?.() ?? /* @__PURE__ */ new Date()).toISOString()
+    });
+    raised = r.raised.length;
+    known = r.known.length;
+    qProblems.push(...r.problems);
+  }
+  const open = hasQuestions ? (await listQuestions(root, { repo, state: "open" })).questions : [];
+  const badLines = parsed.bad.map((b) => ({
+    line: b.line,
+    raw: b.raw,
+    message: `line ${b.line} isn't a fact: ${b.issues.map((i) => i.message).join("; ")}`
+  }));
+  const summary = await writeVerifyFiles(root, repo, report, commit, qProblems, badLines, reviewedBad);
+  const failed = report.rejected.length + qProblems.length + badLines.length + reviewedBad.length > 0;
+  const rejectedNote = `Nothing written to the catalog: ${report.rejected.length} facts were rejected. Fix them and run atticus verify ${repo} --write again.`;
+  if (o.json) {
+    let written2;
+    if (o.write && !failed) {
+      const { writeFactsIntoCatalog: writeFactsIntoCatalog2 } = await import("./chunk-PCOCACY3.js");
+      written2 = await writeFactsIntoCatalog2(root, repo, report.accepted, { dir, command: `atticus verify ${repo} --write` }, { ...io, out: () => void 0 });
+      if (!written2)
+        return 1;
+    } else if (o.write)
+      io.err(rejectedNote);
+    io.out(JSON.stringify({
+      ...summary,
+      questions: {
+        lines: qLines,
+        raised,
+        known,
+        refused: qProblems.length,
+        open: open.length,
+        problems: qProblems
+      },
+      ...reviewedBad.length ? { reviewedProblems: reviewedBad } : {},
+      ...written2 ? { written: written2 } : {}
+    }, null, 2));
+    return failed ? 1 : 0;
+  }
+  const pct = Math.round(report.coverage.ratio * 100);
+  const cov = report.coverage;
+  io.out(`${repo}: ${report.accepted.length} facts kept, ${report.rejected.length} rejected; coverage ${pct}% (${cov.read.length} read, ${cov.reviewed.length ? `${cov.reviewed.length} reviewed with nothing to record, ` : ""}${cov.unknown.length} unknown${cov.excluded.length ? `, ${cov.excluded.length} excluded` : ""}).`);
+  const verifyYaml = `${rel}/${repo}.verify.yaml`;
+  const rejectedFile = `${rel}/${repo}.rejected.jsonl`;
+  const show = (lines, more) => {
+    for (const l of lines.slice(0, SHOWN))
+      io.out(`  ${l}`);
+    if (lines.length > SHOWN)
+      io.out(`  ... and ${lines.length - SHOWN} more ${more}`);
+  };
+  if (report.carried.length) {
+    const from = [...new Set(report.carried.map((c) => c.from.slice(0, 12)))];
+    io.out(`${report.carried.length} of them carried to ${commit.slice(0, 12)} from ${from.slice(0, SHOWN).join(", ")}${from.length > SHOWN ? ` and ${from.length - SHOWN} more commits` : ""}: every file they cite is unchanged since, and their lines were checked again (listed under carried in ${verifyYaml}).`);
+  }
+  const changed = report.rejected.filter((r) => r.code === "cite-changed").length;
+  if (changed)
+    io.out(`${changed} cite a file that changed since they were read: read those files again (atticus map ${repo} --estimate lists them), then rewrite or drop each fact.`);
+  if (missing.length) {
+    io.out(`Facts of ${missing.length === 1 ? "a commit" : `${missing.length} commits`} this clone doesn't have can't be compared with ${commit.slice(0, 12)}: they are rejected as wrong-commit; read them again.`);
+    show(missing.map((c) => c.slice(0, 12)), "commits");
+  }
+  const fixed = report.corrections.applied;
+  if (fixed.length) {
+    io.out(`${fixed.length} ${fixed.length === 1 ? "correction" : "corrections"} by a person applied (${rel}/${repo}.corrections.jsonl; listed under corrections in ${verifyYaml}):`);
+    show(fixed.map((a) => `${a.fact} ${a.action === "wrong" ? "left out as wrong" : "as corrected"}`), `(corrections in ${verifyYaml})`);
+  }
+  const stale = report.corrections.stale;
+  if (stale.length)
+    show(stale.map((s) => `correction: ${s.message}`), `corrections meeting no fact (corrections.stale in ${verifyYaml})`);
+  show(report.rejected.map((r) => `${r.code}: ${r.message}`), `rejected (all in ${rejectedFile})`);
+  if (hasQuestions) {
+    io.out(`${raised} question${raised === 1 ? "" : "s"} raised for a person now${known ? `, ${known} raised before` : ""}${qProblems.length ? `, ${qProblems.length} refused` : ""} (of ${qLines} line${qLines === 1 ? "" : "s"} in ${rel}/${repo}.questions.jsonl).`);
+    if (open.length) {
+      io.out(`${open.length} question${open.length === 1 ? "" : "s"} open for ${repo}, waiting for a person's answer (atticus questions list --state open lists them all; a person answers, never the assistant):`);
+      show(open.map((q) => `${q.id}: ${q.question}`), "open");
+    }
+  }
+  show(qProblems.map((q) => `bad-question: ${q.message}`), `refused questions (all in ${rejectedFile})`);
+  show(badLines.map((b) => `schema: ${b.message}`), `lines that aren't facts (all in ${rejectedFile})`);
+  show(reviewedBad.map((b) => `bad-reviewed: ${b.message}`), `refused reviewed lines (all in ${rejectedFile})`);
+  if (failed)
+    io.out(`Fix them from ${rel}/${repo}.rejected.jsonl (read the lines again, then rewrite or drop each fact, question or reviewed line) and run atticus verify ${repo} again.`);
+  else if (cov.unknown.length)
+    io.out(`Next: read the ${cov.unknown.length} unknown files (listed in ${rel}/${repo}.verify.yaml). A file you read and found nothing to record in goes in ${rel}/${repo}.reviewed.jsonl ({"path": "<file or glob>", "why": "..."} per line); generated code is excluded in org-pack/scan/${repo}.yaml.`);
+  else
+    io.out(`The read is complete: every source file is read (${cov.read.length})${cov.reviewed.length ? ` or reviewed with nothing to record (${cov.reviewed.length}, each with why in ${rel}/${repo}.verify.yaml)` : ""}.`);
+  if (report.redacted)
+    io.out(`${report.redacted} quotes had a secret value redacted.`);
+  if (report.quotesDropped)
+    io.out(`${report.quotesDropped} ${report.quotesDropped === 1 ? "quote was" : "quotes were"} left off (the cited line is minified, a notebook, binary or over 1,000 characters, and the quote doesn't match it); the claim itself was still checked on the line.`);
+  const noAuth = report.authUncited;
+  if (noAuth.length) {
+    io.out(`${noAuth.length} ${noAuth.length === 1 ? "entry's" : "entries'"} auth rests on no cited line (all under authUncited in ${verifyYaml}). ${noAuth.length === 1 ? "It is" : "They are"} kept in ${rel}/${repo}.jsonl, as the reader wrote ${noAuth.length === 1 ? "it" : "them"}, and left out of the catalog, so the map never says an auth nothing shows. To record ${noAuth.length === 1 ? "it" : "them"}: give each entry an authCite \u2014 the file and line that sets the auth and what it writes there \u2014 and run atticus verify ${repo} again:`);
+    show(noAuth.map((a) => `${a.id} (${a.auth}, ${a.cite})`), `(authUncited in ${verifyYaml})`);
+  }
+  const unfollowed = report.entriesNoFlowFollows;
+  if (unfollowed.length) {
+    io.out(`${unfollowed.length} ${unfollowed.length === 1 ? "entry" : "entries"} no flow follows (a note, not a rejection; listed under entriesNoFlowFollows in ${verifyYaml}): write a flow for each that does real work.`);
+    show(unfollowed.map((e) => `${e.entryType === "rest" && e.method ? e.method : e.entryType} ${e.path} (${e.id}, ${e.cite})`), `(entriesNoFlowFollows in ${verifyYaml})`);
+  }
+  const fws = frameworkFacts(report.accepted);
+  if (fws.length)
+    io.out(`Built on ${fws.map((f) => `${f.name}${f.version ? ` ${f.version}` : ""}`).join(", ")} (frameworks in ${verifyYaml}).`);
+  const gaps = report.frameworkGaps;
+  if (gaps.length) {
+    io.out(`${gaps.length} ${gaps.length === 1 ? "framework" : "frameworks"} this repo declares ${gaps.length === 1 ? "shows" : "show"} none of its patterns in the facts (a question for a person, not a rejection; under frameworkGaps in ${verifyYaml}):`);
+    show(gaps.map((g) => g.question), `(frameworkGaps in ${verifyYaml})`);
+  }
+  const learn = frameworksToLearn(report.accepted, await frameworksKnownTo(root));
+  if (learn.length) {
+    io.out(`${learn.length} ${learn.length === 1 ? "framework" : "frameworks"} of the house nothing here can read yet: teach ${learn.length === 1 ? "it" : "them"} once, rather than having each repo's annotations read as ordinary code.`);
+    show(learn.map((l) => `${l.why} Learn it: ${l.command}`), "");
+  }
+  if (failed) {
+    if (o.write)
+      io.err(rejectedNote);
+    return 1;
+  }
+  if (!o.write) {
+    io.out(`When the read is complete: atticus verify ${repo} --write puts the facts in the catalog, the flows in specs/${repo}/, and renders the map.`);
+    return 0;
+  }
+  const { writeFactsIntoCatalog } = await import("./chunk-PCOCACY3.js");
+  const written = await writeFactsIntoCatalog(root, repo, report.accepted, { dir, command: `atticus verify ${repo} --write`, verbose: o.verbose === true }, io);
+  return written ? 0 : 1;
+}
+export {
+  SHOWN,
+  verifyCommand
+};

package/dist/chunk-JZU3H6UQ.js

@@ -0,0 +1,54 @@
+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 {
+  completionOf,
+  handoffDone,
+  openspecCheck,
+  openspecSetup,
+  workspaceOpen,
+  workspacePrune,
+  workspaceSync
+} from "./chunk-4BN53TG3.js";
+import "./chunk-2VHF7OXM.js";
+import "./chunk-KEM4SDDP.js";
+import "./chunk-6M5NK3K3.js";
+import "./chunk-LR3R6Z2A.js";
+import "./chunk-AA6YULYB.js";
+import "./chunk-BWZ77RQT.js";
+import "./chunk-HITVBIJS.js";
+import "./chunk-2ANOROX3.js";
+import "./chunk-65NYPGRC.js";
+import "./chunk-VOGCSYOI.js";
+import "./chunk-OT2O76OS.js";
+import "./chunk-IPKHE5D6.js";
+import "./chunk-CKSITVS4.js";
+import "./chunk-L6SGQIR3.js";
+import "./chunk-3HI6Z55Y.js";
+import "./chunk-XY3P7JW7.js";
+import "./chunk-4AK7IBVP.js";
+import "./chunk-7JUKDRSZ.js";
+import "./chunk-27NKUS3X.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-EFHQ3TWP.js";
+import "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+export {
+  completionOf,
+  handoffDone,
+  openspecCheck,
+  openspecSetup,
+  workspaceOpen,
+  workspacePrune,
+  workspaceSync
+};

package/dist/chunk-K65BJIMT.js

@@ -0,0 +1,49 @@
+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 {
+  matchedRepoType,
+  onboardAccept,
+  onboardCheck,
+  onboardDraft,
+  onboardEval,
+  onboardFramework,
+  onboardFrameworkAccept,
+  onboardFrameworkCheck,
+  scanReview,
+  scanSurvey
+} from "./chunk-GLUX4EEP.js";
+import "./chunk-FITWGOJ2.js";
+import {
+  repoFor
+} from "./chunk-O3WI5KWW.js";
+import "./chunk-KEM4SDDP.js";
+import "./chunk-ZVM6AKKM.js";
+import "./chunk-27NKUS3X.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-EFHQ3TWP.js";
+import "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+export {
+  matchedRepoType,
+  onboardAccept,
+  onboardCheck,
+  onboardDraft,
+  onboardEval,
+  onboardFramework,
+  onboardFrameworkAccept,
+  onboardFrameworkCheck,
+  repoFor,
+  scanReview,
+  scanSurvey
+};