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

package/dist/chunk-REWWDVQB.js

@@ -0,0 +1,162 @@
+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 {
+  ABOUT_RULE,
+  ASSISTANT_FORMATS,
+  AssistantFilesError,
+  BEGIN_RE,
+  COPILOT_AGENTS,
+  COPILOT_RULES,
+  END,
+  FACT_RULES,
+  FACT_RULES_HASH,
+  FACT_RULE_PARTS,
+  FINISH,
+  FRAMEWORK_TOPICS,
+  GUARD,
+  MODELS_RULE,
+  OrgCommandMeta,
+  PROBE_DIR,
+  PROBE_SCHEMA_VERSION,
+  PROBE_STALE_DAYS,
+  PROPOSAL_SHAPE,
+  ProbeResult,
+  RULE_SETS,
+  RULE_TOPICS,
+  SPEC_KIT_VERSION,
+  UNRECORDED_LACKS,
+  agentFile,
+  assistantTier,
+  atticusTaskCommand,
+  body,
+  buildEngineFor,
+  claudeCodePluginFiles,
+  claudeCommandContent,
+  copilotAgentFiles,
+  describeStep,
+  factRulesFor,
+  factsReference,
+  fileText,
+  findSection,
+  generateAssistantFiles,
+  headerLine,
+  loadOrgCommands,
+  mapBatchInstructions,
+  mapCommand,
+  metarepoCommands,
+  parseHeader,
+  probeCommand,
+  probeFileOf,
+  probeTier,
+  probedAssistant,
+  proposeCommand,
+  protocolFor,
+  readProbes,
+  renderAssistantFiles,
+  renderSection,
+  ruleSetKinds,
+  ruleSetsNow,
+  rulesLacking,
+  rulesNow,
+  serializeProbe,
+  sha256,
+  smokeCheck,
+  specKitCommands,
+  specifyFiles,
+  step,
+  stepCommands,
+  taughtFrameworksText,
+  tierLine,
+  tierSource,
+  tierWords,
+  topUpWords,
+  whatRunsWhere,
+  withHeader,
+  writeAssistantFiles,
+  writeProbe,
+  zeroInstallCommands
+} from "./chunk-BEVTIBRH.js";
+import "./chunk-PKBHS4AA.js";
+import "./chunk-Q2TECDIT.js";
+import "./chunk-TUULXQRW.js";
+import "./chunk-BQGDB6ZL.js";
+import "./chunk-TV45EUGM.js";
+export {
+  ABOUT_RULE,
+  ASSISTANT_FORMATS,
+  AssistantFilesError,
+  BEGIN_RE,
+  COPILOT_AGENTS,
+  COPILOT_RULES,
+  END,
+  FACT_RULES,
+  FACT_RULES_HASH,
+  FACT_RULE_PARTS,
+  FINISH,
+  FRAMEWORK_TOPICS,
+  GUARD,
+  MODELS_RULE,
+  OrgCommandMeta,
+  PROBE_DIR,
+  PROBE_SCHEMA_VERSION,
+  PROBE_STALE_DAYS,
+  PROPOSAL_SHAPE,
+  ProbeResult,
+  RULE_SETS,
+  RULE_TOPICS,
+  SPEC_KIT_VERSION,
+  UNRECORDED_LACKS,
+  agentFile,
+  assistantTier,
+  atticusTaskCommand,
+  body,
+  buildEngineFor,
+  claudeCodePluginFiles,
+  claudeCommandContent,
+  copilotAgentFiles,
+  describeStep,
+  factRulesFor,
+  factsReference,
+  fileText,
+  findSection,
+  generateAssistantFiles,
+  headerLine,
+  loadOrgCommands,
+  mapBatchInstructions,
+  mapCommand,
+  metarepoCommands,
+  parseHeader,
+  probeCommand,
+  probeFileOf,
+  probeTier,
+  probedAssistant,
+  proposeCommand,
+  protocolFor,
+  readProbes,
+  renderAssistantFiles,
+  renderSection,
+  ruleSetKinds,
+  ruleSetsNow,
+  rulesLacking,
+  rulesNow,
+  serializeProbe,
+  sha256,
+  smokeCheck,
+  specKitCommands,
+  specifyFiles,
+  step,
+  stepCommands,
+  taughtFrameworksText,
+  tierLine,
+  tierSource,
+  tierWords,
+  topUpWords,
+  whatRunsWhere,
+  withHeader,
+  writeAssistantFiles,
+  writeProbe,
+  zeroInstallCommands
+};

package/dist/{chunk-JMSCMUCA.js → chunk-RGERPOIV.js}

@@ -3,46 +3,61 @@ 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 {
+  componentTypeIds,
+  componentTypesAt
+} from "./chunk-OUBGGKDU.js";
+import {
+  recordTopUpVerified
+} from "./chunk-XI2LCCYQ.js";
+import {
+  notesAt
+} from "./chunk-WXFLMQSR.js";
+import {
+  loadReadPlan,
+  recordReadProgress
+} from "./chunk-TYQBFTBR.js";
 import {
   carryOf,
   checkoutOf,
+  conventionsAt,
+  estateComponentsOf,
   excludesOf,
   headOf,
   raiseReadQuestions,
   readCorrections,
   readReviewed,
   reviewedProblemsOf,
+  slipNoteLines,
   writeVerifyFiles
-} from "./chunk-CR3MTH32.js";
-import "./chunk-O3WI5KWW.js";
+} from "./chunk-2F4CYZKJ.js";
 import {
   dirSource,
   frameworkFacts,
   frameworksToLearn,
+  repairFormSlips,
   verifyFacts
-} from "./chunk-PAMPPUR6.js";
+} from "./chunk-CXJ6FUKN.js";
 import {
   NoRoomError,
   roomGuard,
   streamFacts
-} from "./chunk-EPTBZ3GP.js";
-import "./chunk-EFHQ3TWP.js";
-import "./chunk-GQ4N4WKF.js";
+} from "./chunk-UPS2DGFC.js";
 import {
   factsDirOf,
   factsRelOf,
   listQuestions,
-  loadOrgPack
-} from "./chunk-S2A7YC3Q.js";
-import "./chunk-D3PO4DOZ.js";
-import "./chunk-TV45EUGM.js";
+  loadOrgPack,
+  orgPackDirOf,
+  stackHelpersOff
+} from "./chunk-Q2TECDIT.js";
 
 // packages/cli/dist/verify-commands.js
 import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
+import { readdir, readFile } from "node:fs/promises";
 import { join } from "node:path";
 async function frameworksKnownTo(root) {
-  const op = await loadOrgPack(root).catch(() => void 0);
+  const op = await loadOrgPack(orgPackDirOf(root)).catch(() => void 0);
   return (op?.frameworks ?? []).flatMap((f) => [f.name, ...f.artifacts]);
 }
 var SHOWN = 5;
@@ -63,7 +78,44 @@ function questionLines(text) {
   }
   return { lines, problems };
 }
+var FACTS_SIDE_FILES = /\.(questions|reviewed|rejected|corrections)\.jsonl$/;
+async function factsRepos(root) {
+  const names = await readdir(factsDirOf(root)).catch(() => []);
+  return names.filter((n) => n.endsWith(".jsonl") && !FACTS_SIDE_FILES.test(n)).map((n) => n.slice(0, -".jsonl".length)).sort();
+}
+async function verifyAllCommand(root, o, io) {
+  const repos = await factsRepos(root);
+  if (!repos.length) {
+    io.err(`No repo has facts yet (${factsRelOf(root)}/<repo>.jsonl). Read one first: /atticus-map <repo> in your assistant.`);
+    return 2;
+  }
+  const failed = [];
+  for (const repo of repos) {
+    const code = await verifyCommand(root, repo, o, io);
+    if (code !== 0)
+      failed.push(repo);
+  }
+  const passed = repos.length - failed.length;
+  io.out(`Verified ${repos.length === 1 ? "1 repo" : `${repos.length} repos`}: ${passed} passed${failed.length ? `, ${failed.length} with something to fix (${failed.join(", ")})` : ""}.`);
+  return failed.length ? 1 : 0;
+}
+async function verifyInputsOf(root, repo, dir) {
+  return {
+    // ADR 0163: the org notes the read was handed, so a term's note is one of them.
+    notes: (await notesAt(root, repo, dir)).notes,
+    // ADR 0180: a component fact's type is one of the organisation's.
+    componentTypes: componentTypeIds(await componentTypesAt(root)),
+    corrections: await readCorrections(root, repo),
+    reviewed: await readReviewed(root, repo),
+    estate: await estateComponentsOf(root),
+    conventions: await conventionsAt(root),
+    exclude: await excludesOf(root, repo),
+    // ADR 0169: the model files the read plan leaves out, counted apart in coverage.
+    notReached: (await loadReadPlan(root, repo))?.notReached?.files ?? []
+  };
+}
 async function verifyCommand(root, repo, o, io) {
+  const off = stackHelpersOff();
   const rel = factsRelOf(root);
   const file = join(factsDirOf(root), `${repo}.jsonl`);
   if (!existsSync(file)) {
@@ -83,6 +135,9 @@ async function verifyCommand(root, repo, o, io) {
     io.err(`atticus verify ${repo}: ${e.message}`);
     return 2;
   }
+  const repaired = repairFormSlips(parsed.facts, parsed.bad);
+  parsed = { facts: repaired.facts, bad: repaired.bad };
+  const slips = repaired.slips;
   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))
@@ -99,23 +154,32 @@ async function verifyCommand(root, repo, o, io) {
   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);
+  const inputs = await verifyInputsOf(root, repo, dir);
+  const { corrections, reviewed, estate, conventions } = inputs;
   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,
+      // G4: the stack helpers this run switched off (ATTICUS_HELPERS_OFF).
+      ...off.has("derived-names") ? { derivedNames: false } : {},
+      ...off.has("readers") ? { readers: false } : {},
       ...commit ? { commit, carry } : {},
       ...o.routed ? { routed: o.routed } : {},
-      exclude: await excludesOf(root, repo),
+      exclude: inputs.exclude,
       corrections: corrections.corrections,
       reviewed: reviewed.entries,
-      room
+      room,
+      // J1 (ADR 0143): an exposure read here names a component the manifest lists.
+      ...estate ? { estate } : {},
+      conventions,
+      notes: inputs.notes,
+      componentTypes: inputs.componentTypes,
+      notReached: inputs.notReached
     });
   } catch (e) {
     if (!(e instanceof NoRoomError))
@@ -151,13 +215,24 @@ async function verifyCommand(root, repo, o, io) {
     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 summary = await writeVerifyFiles(root, repo, report, commit, qProblems, badLines, reviewedBad, slips);
   const failed = report.rejected.length + qProblems.length + badLines.length + reviewedBad.length > 0;
+  await recordReadProgress(root, repo, {
+    commit,
+    kept: report.accepted.length,
+    // ADR 0170: a part is read when this coverage leaves nothing under it unaccounted.
+    unknown: report.coverage.unknown,
+    ...o.now ? {
+      now: o.now().toISOString().replace(/\.\d{3}Z$/, "Z")
+    } : {}
+  });
+  if (!failed)
+    await recordTopUpVerified(root, repo, { commit });
   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");
+      const { writeFactsIntoCatalog: writeFactsIntoCatalog2 } = await import("./chunk-Y2EQNWKV.js");
       written2 = await writeFactsIntoCatalog2(root, repo, report.accepted, { dir, command: `atticus verify ${repo} --write` }, { ...io, out: () => void 0 });
       if (!written2)
         return 1;
@@ -180,7 +255,16 @@ async function verifyCommand(root, repo, o, io) {
   }
   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` : ""}).`);
+  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` : ""}${cov.notReached.length ? `, ${cov.notReached.length} model files no entry or call reaches` : ""}).`);
+  if (cov.notReached.length) {
+    const client = new Set((await loadReadPlan(root, repo))?.notReached?.clientOnly?.files ?? []);
+    const byClient = cov.notReached.filter((p) => client.has(p)).length;
+    const rest = cov.notReached.length - byClient;
+    if (byClient)
+      io.out(`${byClient} model files only an outbound client reaches; atticus map ${repo} --models reachable reads them.`);
+    if (rest)
+      io.out(`${rest} model files no entry or call reaches; atticus map ${repo} --models all reads them.`);
+  }
   const verifyYaml = `${rel}/${repo}.verify.yaml`;
   const rejectedFile = `${rel}/${repo}.rejected.jsonl`;
   const show = (lines, more) => {
@@ -225,6 +309,42 @@ async function verifyCommand(root, repo, o, io) {
     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)` : ""}.`);
+  for (const l of slipNoteLines(slips, verifyYaml, SHOWN))
+    io.out(l);
+  const dropped = report.reviewedDropped;
+  if (dropped.length) {
+    io.out(`${dropped.length} reviewed ${dropped.length === 1 ? "glob matches" : "globs match"} no file and ${dropped.length === 1 ? "was" : "were"} dropped (a note, not a refusal; under reviewedDropped in ${verifyYaml}):`);
+    show(dropped.map((d) => d.message), `(reviewedDropped in ${verifyYaml})`);
+  }
+  const unseen = report.methodUnseen;
+  if (unseen.length) {
+    io.out(`${unseen.length} ${unseen.length === 1 ? "entry or call claims" : "entries or calls claim"} an HTTP method ${unseen.length === 1 ? "its" : "their"} lines don't write (a warning, not a rejection; under methodUnseen in ${verifyYaml}):`);
+    show(unseen.map((m) => m.message), `(methodUnseen in ${verifyYaml})`);
+  }
+  const all = o.skipped === true;
+  const list = (lines, more) => {
+    if (all)
+      for (const l of lines)
+        io.out(`  ${l}`);
+    else
+      show(lines, more);
+  };
+  const seeAll = `atticus verify ${repo} --skipped prints every one`;
+  const skippedLines = report.skipped;
+  if (skippedLines.length) {
+    io.out(`${skippedLines.length} ${skippedLines.length === 1 ? "line of the files read writes" : "lines of the files read write"} a path, URL or topic no fact cites (a note for the reader to check, not a rejection; under skipped in ${verifyYaml}; ${seeAll}):`);
+    list(skippedLines.map((x) => `${x.cite} ${x.kind} ${x.value}`), `(${seeAll})`);
+  }
+  const holds = report.reviewedHolds;
+  if (holds.length) {
+    io.out(`${holds.length} reviewed ${holds.length === 1 ? "glob holds" : "globs hold"} lines that write a path, URL or topic (a note; under reviewedHolds in ${verifyYaml}): read them, then write their facts or say why there are none:`);
+    list(holds.map((h) => h.message), `(reviewedHolds in ${verifyYaml})`);
+  }
+  const ops = report.specOpsUncovered;
+  if (ops.length) {
+    io.out(`${ops.length} ${ops.length === 1 ? "operation the repo's OpenAPI spec declares has" : "operations the repo's OpenAPI specs declare have"} no entry (a note, not a rejection; under specOpsUncovered in ${verifyYaml}; ${seeAll}):`);
+    list(ops.map((x) => x.message), `(${seeAll})`);
+  }
   if (report.redacted)
     io.out(`${report.redacted} quotes had a secret value redacted.`);
   if (report.quotesDropped)
@@ -247,7 +367,7 @@ async function verifyCommand(root, repo, o, io) {
     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));
+  const learn = off.has("framework-models") ? [] : frameworksToLearn(report.accepted, await frameworksKnownTo(root), (await conventionsAt(root)).frameworks);
   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}`), "");
@@ -261,11 +381,15 @@ async function verifyCommand(root, repo, o, io) {
     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 { writeFactsIntoCatalog } = await import("./chunk-Y2EQNWKV.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,
+  factsRepos,
+  verifyAllCommand,
+  verifyInputsOf,
   verifyCommand
 };

package/dist/{chunk-6JCPI55B.js → chunk-RLDGWLQ7.js}

@@ -14,6 +14,8 @@ import {
   SERVICE_REQUEST_READER,
   TriageError,
   WORK_ITEM_READER,
+  aggregateTraffic,
+  appLabelOf,
   attachToChange,
   boundedId,
   buildTriage,
@@ -21,34 +23,54 @@ import {
   citedParts,
   classify,
   compareVersions,
+  denyListHits,
   diffVendorSpecs,
   heldOutInputs,
+  joinServerVariables,
+  looksSensitive,
   nameParts,
+  openApiContractSpecs,
   operationSchemas,
   opt,
+  pathTemplateOf,
   payloadFields,
   readAsyncApiSpec,
+  readAsyncApiSpecs,
+  readAvroSpecs,
   readChangeInputs,
+  readConsumerOpenApi,
+  readContractFiles,
+  readContractSpecs,
+  readJsonSchemaSpecs,
   readOpenApiSpec,
+  readPactFile,
   readPayload,
+  readProtoSpecs,
+  readRepoSpecs,
   readServiceRequestExport,
   readServiceRequestExports,
   readVendorSpec,
   readWorkItemExport,
   readWorkItemExports,
+  safePathOf,
+  safeServerUrl,
   scanInputs,
   screenFile,
+  segmentOf,
   slug,
   sortItems,
   specEndpointIds,
+  specFormatOf,
   vendorImpact
-} from "./chunk-23W7VWKR.js";
-import "./chunk-7EKXJZ2Y.js";
-import "./chunk-MC3H7736.js";
-import "./chunk-GQ4N4WKF.js";
-import "./chunk-CNUKCS2T.js";
-import "./chunk-S2A7YC3Q.js";
-import "./chunk-D3PO4DOZ.js";
+} from "./chunk-QKUJMING.js";
+import "./chunk-6ZGLAACW.js";
+import "./chunk-CQDGOPGH.js";
+import "./chunk-3NFFJL5D.js";
+import "./chunk-P32RUW3B.js";
+import "./chunk-QA4O2GGC.js";
+import "./chunk-Q2TECDIT.js";
+import "./chunk-TUULXQRW.js";
+import "./chunk-BQGDB6ZL.js";
 import "./chunk-TV45EUGM.js";
 export {
   CHANGE_INPUTS_SCHEMA_VERSION,
@@ -61,6 +83,8 @@ export {
   SERVICE_REQUEST_READER,
   TriageError,
   WORK_ITEM_READER,
+  aggregateTraffic,
+  appLabelOf,
   attachToChange,
   boundedId,
   buildTriage,
@@ -68,25 +92,43 @@ export {
   citedParts,
   classify,
   compareVersions,
+  denyListHits,
   diffVendorSpecs,
   heldOutInputs,
+  joinServerVariables,
+  looksSensitive,
   nameParts,
+  openApiContractSpecs,
   operationSchemas,
   opt,
+  pathTemplateOf,
   payloadFields,
   readAsyncApiSpec,
+  readAsyncApiSpecs,
+  readAvroSpecs,
   readChangeInputs,
+  readConsumerOpenApi,
+  readContractFiles,
+  readContractSpecs,
+  readJsonSchemaSpecs,
   readOpenApiSpec,
+  readPactFile,
   readPayload,
+  readProtoSpecs,
+  readRepoSpecs,
   readServiceRequestExport,
   readServiceRequestExports,
   readVendorSpec,
   readWorkItemExport,
   readWorkItemExports,
+  safePathOf,
+  safeServerUrl,
   scanInputs,
   screenFile,
+  segmentOf,
   slug,
   sortItems,
   specEndpointIds,
+  specFormatOf,
   vendorImpact
 };