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

package/dist/chunk-PCOCACY3.js

@@ -1,385 +0,0 @@
-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 {
-  diffLines
-} from "./chunk-JGZCG5VM.js";
-import {
-  askHosts
-} from "./chunk-RVH5SUW5.js";
-import "./chunk-OT2O76OS.js";
-import "./chunk-IPKHE5D6.js";
-import "./chunk-3HI6Z55Y.js";
-import "./chunk-XY3P7JW7.js";
-import "./chunk-4AK7IBVP.js";
-import "./chunk-7JUKDRSZ.js";
-import {
-  TARGETS_STEP,
-  catalogWithFacts,
-  diffCatalogs,
-  diffIsEmpty,
-  estateFacts,
-  isPrototypeRepo,
-  prototypeLeftOut,
-  readCatalog,
-  targetQuestionDrafts,
-  targetsFromAnswers,
-  writeCatalog
-} from "./chunk-27NKUS3X.js";
-import "./chunk-L24C55VN.js";
-import {
-  codeLinkerFor,
-  frameworkFacts,
-  frameworkGaps,
-  renderMap,
-  trustOf
-} from "./chunk-PAMPPUR6.js";
-import "./chunk-23W7VWKR.js";
-import "./chunk-7EKXJZ2Y.js";
-import "./chunk-MC3H7736.js";
-import {
-  baseClonePath,
-  loadRepos
-} from "./chunk-EFHQ3TWP.js";
-import "./chunk-GQ4N4WKF.js";
-import "./chunk-CNUKCS2T.js";
-import {
-  SPEC_HEADER_SCHEMA_VERSION,
-  catalogDirOf,
-  factsDirOf,
-  flowFiles,
-  isAdopted,
-  listQuestions,
-  loadOrgPack,
-  mapDirOf,
-  mapRelOf,
-  orgPackDirOf,
-  parseFacts,
-  parseRecord,
-  questionsRelOf,
-  raiseQuestions,
-  readRepoSpec,
-  removeFlow,
-  require_dist,
-  specFileHash,
-  specRelOf,
-  writeFlow,
-  writeSpecHeader
-} from "./chunk-S2A7YC3Q.js";
-import {
-  LockHeldError,
-  acquireLock,
-  writeFileAtomic
-} from "./chunk-D3PO4DOZ.js";
-import {
-  __toESM
-} from "./chunk-TV45EUGM.js";
-
-// packages/cli/dist/map-render-commands.js
-var import_yaml = __toESM(require_dist(), 1);
-import { existsSync } from "node:fs";
-import { readFile, readdir, rm } from "node:fs/promises";
-import { join, relative, sep } from "node:path";
-var FACTS_TEMPLATE = "facts@1";
-var posix = (p) => p.split(sep).join("/");
-function countByKind(d) {
-  const out = {};
-  const of = (k) => out[k] ??= { added: 0, changed: 0, removed: 0 };
-  for (const r of d.added)
-    of(r.kind).added++;
-  for (const r of [...d.changed, ...d.evidenceOnly])
-    of(r.kind).changed++;
-  for (const r of d.removed)
-    of(r.kind).removed++;
-  return Object.fromEntries(Object.entries(out).sort(([a], [b]) => a < b ? -1 : 1));
-}
-function kindLine(byKind) {
-  const parts = Object.entries(byKind).map(([kind, c]) => [
-    kind,
-    c.added ? `+${c.added}` : "",
-    c.changed ? `~${c.changed}` : "",
-    c.removed ? `-${c.removed}` : ""
-  ].filter(Boolean).join(" "));
-  return parts.join(", ");
-}
-async function writeFactsIntoCatalog(root, repo, facts, o, io) {
-  let lock;
-  try {
-    lock = await acquireLock(root, "scan", o.command);
-  } catch (e) {
-    if (e instanceof LockHeldError) {
-      io.err(e.message);
-      return void 0;
-    }
-    throw e;
-  }
-  try {
-    const op = await loadOrgPack(orgPackDirOf(root));
-    const generated = join(catalogDirOf(root), "generated");
-    const existing = await readCatalog(generated, { cacheRoot: root });
-    if (isPrototypeRepo(op, repo)) {
-      for (const n of prototypeLeftOut({ repo, facts, existing: [], op, decisions: [] }).notes)
-        io.out(n);
-      const none = diffCatalogs(existing.records, existing.records);
-      return {
-        written: { written: 0, unchanged: 0, removed: 0 },
-        flows: [],
-        questions: [],
-        map: [],
-        changes: { ...none, byKind: {} }
-      };
-    }
-    const curated = await readCatalog(join(catalogDirOf(root), "curated"), { cacheRoot: root });
-    const rerun = `atticus verify ${repo} --write`;
-    const answered = (await listQuestions(root, { repo, step: TARGETS_STEP })).questions;
-    const estate = await estateFacts(root, op, repo);
-    const result = catalogWithFacts({
-      repo,
-      facts,
-      existing: existing.records,
-      op,
-      decisions: curated.records,
-      targets: targetsFromAnswers(repo, facts, answered),
-      estate: estate.repos,
-      estateTargets: estate.targets
-    });
-    for (const i of result.invalid)
-      io.err(`A merged record isn't valid C1 (a bug): ${i.issues.map((x) => `${x.path}: ${x.message}`).join("; ")}`);
-    const diff = diffCatalogs(existing.records, result.records);
-    const written = await writeCatalog(generated, result.records);
-    const flows = result.flows.filter((f) => {
-      const p = parseRecord(f);
-      if (p.ok)
-        return true;
-      io.err(`The flow ${f.id} isn't written to ${specRelOf(root, repo)}/: ${p.issues.map((i) => `${i.path}: ${i.message}`).join("; ")}. Have your assistant fix its flow fact (each call-out step's ref names the call it makes), then run ${rerun}.`);
-      return false;
-    });
-    const spec = await readRepoSpec(root, repo, { cacheRoot: root });
-    const ids = new Set(flows.map((f) => f.id));
-    for (const f of spec.flows)
-      if (f.template === FACTS_TEMPLATE && !ids.has(f.id))
-        await removeFlow(root, repo, f.id);
-    const flowPaths = [];
-    for (const f of flows)
-      flowPaths.push(await writeFlow(root, repo, f));
-    const files = {};
-    for (const f of flows)
-      for (const p of flowFiles(f)) {
-        const text = await readFile(join(o.dir, ...p.split("/")), "utf8").catch(() => void 0);
-        if (text !== void 0)
-          files[p] = specFileHash(text);
-      }
-    const commit = facts.map((f) => f.commit).sort()[0];
-    const kept = spec.flows.filter((f) => f.template !== FACTS_TEMPLATE).map((f) => f.id);
-    const header = spec.header;
-    await writeSpecHeader(root, {
-      schemaVersion: SPEC_HEADER_SCHEMA_VERSION,
-      repo,
-      template: header?.template ?? FACTS_TEMPLATE,
-      templateReviewed: header?.templateReviewed ?? false,
-      ...commit ? { commit } : {},
-      ...header?.drafted ? { drafted: header.drafted } : {},
-      flows: [.../* @__PURE__ */ new Set([...kept, ...ids])].sort(),
-      files: Object.fromEntries(Object.entries({ ...header?.files ?? {}, ...files }).sort(([a], [b]) => a < b ? -1 : 1)),
-      questions: header?.questions ?? []
-    });
-    const at = (o.now ?? /* @__PURE__ */ new Date()).toISOString();
-    const hosts = await askHosts(root, result.records, { command: o.command, rerun, now: o.now });
-    const loose = new Set(result.unresolved.map((u) => u.factId));
-    const ambiguous = new Set((result.join?.asks ?? []).filter((a) => a.reason === "ambiguous" && a.call.repo === repo).map((a) => a.call.fact));
-    const named = new Set(facts.filter((f) => f.kind === "call" && f.to).map((f) => f.id));
-    const raised = [...hosts.raised];
-    const lines = [...hosts.lines];
-    for (const t of targetQuestionDrafts(facts, result.records, op, result.join?.asks)) {
-      if (!(loose.has(t.factId) || ambiguous.has(t.factId)))
-        continue;
-      if (answered.some((q) => q.id === t.id))
-        continue;
-      const r = await raiseQuestions(root, [t.draft], {
-        step: TARGETS_STEP,
-        repo,
-        command: o.command,
-        rerun,
-        at
-      });
-      for (const q of r.raised) {
-        raised.push(q);
-        lines.push(named.has(t.factId) ? `A call names a target the estate doesn't have, and more than one entry serves it: asked ${q.id}: ${q.question} Answer it: atticus questions answer ${q.id} --option <n>, then ${rerun}.` : `A call names no target: asked ${q.id}: ${q.question} Answer it: atticus questions answer ${q.id} --option <n>, then ${rerun}.`);
-      }
-    }
-    const byKind = countByKind(diff);
-    io.out(`Wrote the catalog for ${repo}: ${written.written} files written, ${written.removed} removed, ${written.unchanged} unchanged.`);
-    io.out(diffIsEmpty(diff) ? "  No catalog changes." : `  Records: ${kindLine(byKind)}.`);
-    if (o.verbose)
-      for (const l of diffLines(diff).slice(1))
-        io.out(`    ${l}`);
-    const specsRel = specRelOf(root, repo);
-    io.out(`  Flows: ${flowPaths.length} in ${specsRel}/.`);
-    if (o.verbose)
-      for (const p of flowPaths)
-        io.out(`    ${p}`);
-    else if (!diffIsEmpty(diff) || flowPaths.length)
-      io.out(`  atticus verify ${repo} --write --verbose lists each record and flow.`);
-    for (const p of result.curated.problems)
-      io.out(`Curated decision ${p.decision} no longer applies: ${p.message}`);
-    for (const p of result.projectionIssues)
-      io.out(`  ${p.code}: ${p.message}`);
-    for (const l of joinLines(repo, result.join, estate.notes, { verbose: o.verbose === true }))
-      io.out(l);
-    for (const l of lines)
-      io.out(l);
-    const map = await renderRepoMap(root, repo, io);
-    return {
-      written,
-      flows: flowPaths,
-      questions: raised.map((q) => q.id),
-      map: map ?? [],
-      changes: { ...diff, byKind }
-    };
-  } finally {
-    await lock.release();
-  }
-}
-function joinLines(repo, join2, notes = [], o = {}) {
-  if (!join2)
-    return [...notes];
-  const out = [...notes];
-  const mine = join2.joins.filter((j) => j.call.repo === repo && j.call.repo !== j.entry.repo);
-  const into = join2.joins.filter((j) => j.entry.repo === repo && j.call.repo !== repo);
-  if (mine.length || into.length)
-    out.push(`Joined across repos: ${mine.length} of ${repo}'s calls to the entries that serve them, ${into.length} calls of other repos into ${repo}, each citing both ends.`);
-  const guessed = join2.joins.filter((j) => j.call.repo === repo && j.inferred);
-  if (guessed.length) {
-    const own = guessed.filter((j) => j.inferred.within === "repo").length;
-    const where = [
-      own ? `${own} in ${repo} itself` : "",
-      guessed.length - own ? `${guessed.length - own} in another repo${guessed.length - own === 1 ? "" : "s"}` : ""
-    ].filter(Boolean).join(", ");
-    out.push(`Joined by method and path, inferred: ${guessed.length} of ${repo}'s calls name no target the estate has, so each joined the one entry that serves it (${where}).`);
-    if (o.verbose)
-      for (const j of guessed) {
-        const what = j.method ? `${j.method} ${j.path}` : j.path;
-        const named = j.inferred.named ? ` (named ${j.inferred.named})` : "";
-        const there = j.entry.repo === repo ? "" : ` (${j.entry.repo})`;
-        out.push(`  ${j.call.at} ${what}${named} \u2192 ${j.entry.component}${there}`);
-      }
-  }
-  for (const m of join2.misses)
-    out.push(`Not joined: ${m.message} (${m.call.at}).`);
-  for (const g of join2.gaps.slice(0, 10))
-    out.push(`Field gap: ${g.message}.`);
-  return out;
-}
-async function renderRepoMap(root, repo, io) {
-  const records = (await readCatalog(join(catalogDirOf(root), "generated"), { cacheRoot: root })).records;
-  const spec = await readRepoSpec(root, repo, { cacheRoot: root });
-  const ofRepo = records.some((r) => r.kind === "Component" && r.repo === repo);
-  if (!ofRepo && spec.flows.length === 0) {
-    io.err(`Nothing of ${repo} is in the catalog yet. Have your assistant read it (/atticus map), then run atticus verify ${repo} --write.`);
-    return void 0;
-  }
-  let trust;
-  const report = join(factsDirOf(root), `${repo}.verify.yaml`);
-  if (existsSync(report)) {
-    try {
-      trust = trustOf((0, import_yaml.parse)(await readFile(report, "utf8")));
-    } catch {
-      trust = void 0;
-    }
-  }
-  const open = (await listQuestions(root, { state: "open", repo })).questions;
-  const manifest = (await loadRepos(root).catch(() => [])).find((r) => r.id === repo);
-  const adopted = isAdopted(root);
-  const url = manifest?.url && manifest.url !== "." && !manifest.url.startsWith("./") ? manifest.url : void 0;
-  const codeLink = codeLinkerFor(url ? { url } : { dir: adopted ? "" : posix(relative(root, baseClonePath(root, repo))) });
-  const rel = `${mapRelOf(root)}/${repo}`;
-  const files = renderMap({
-    repo,
-    records,
-    flows: spec.flows,
-    ...trust ? { trust } : {},
-    // What a person says the repo is (ADR 0128), above the trust line.
-    ...manifest?.description ? {
-      about: {
-        text: manifest.description.text,
-        trust: manifest.description.trust,
-        ...manifest.description.by ? { by: manifest.description.by } : {}
-      }
-    } : {},
-    // What the repo is built on (ADR 0124 addendum A-framework): read from the facts, since no
-    // catalog record holds a framework.
-    ...builtOnOf(await factsOf(root, repo)),
-    questions: open.map((q) => ({ id: q.id, question: q.question, evidence: q.evidence })),
-    paths: { map: rel, questions: questionsRelOf(root), specs: specRelOf(root, repo) },
-    codeLink
-  });
-  const dir = join(mapDirOf(root), repo);
-  for (const old of await listFiles(dir))
-    if (!(old in files))
-      await rm(join(dir, ...old.split("/")), { force: true });
-  for (const [path, text] of Object.entries(files)) {
-    const full = join(dir, ...path.split("/"));
-    const now = await readFile(full, "utf8").catch(() => void 0);
-    if (now !== text)
-      await writeFileAtomic(full, text);
-  }
-  const paths = Object.keys(files).map((p) => `${rel}/${p}`);
-  io.out(`Map: ${rel}/map.md (${Object.keys(files).length} files; review them in the PR).`);
-  return paths;
-}
-async function factsOf(root, repo) {
-  const text = await readFile(join(factsDirOf(root), `${repo}.jsonl`), "utf8").catch(() => void 0);
-  if (text === void 0)
-    return [];
-  const p = parseFacts(text);
-  return p.ok ? p.facts : [];
-}
-function builtOnOf(facts) {
-  const built = frameworkFacts(facts).map((f) => ({
-    name: f.name,
-    ...f.version ? { version: f.version } : {},
-    ...f.component ? { component: f.component } : {},
-    cite: { path: f.cite.file, line: f.cite.line, commit: f.commit }
-  }));
-  if (!built.length)
-    return {};
-  const gaps = frameworkGaps(facts).map((g) => ({ framework: g.framework, question: g.question }));
-  return { frameworks: { built, ...gaps.length ? { gaps } : {} } };
-}
-async function listFiles(dir) {
-  const out = [];
-  const walk = async (d, prefix) => {
-    let entries;
-    try {
-      entries = await readdir(d, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const e of entries)
-      if (e.isDirectory())
-        await walk(join(d, e.name), `${prefix}${e.name}/`);
-      else
-        out.push(`${prefix}${e.name}`);
-  };
-  await walk(dir, "");
-  return out.sort();
-}
-async function mapRenderCommand(root, repo, o, io) {
-  const quiet = o.json ? { ...io, out: () => void 0 } : io;
-  const written = await renderRepoMap(root, repo, quiet);
-  if (!written)
-    return 2;
-  if (o.json)
-    io.out(JSON.stringify({ repo, files: written }, null, 2));
-  return 0;
-}
-export {
-  builtOnOf,
-  countByKind,
-  joinLines,
-  kindLine,
-  mapRenderCommand,
-  writeFactsIntoCatalog
-};

package/dist/chunk-RTEYOSJY.js

@@ -1,29 +0,0 @@
-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 {
-  buildDigest,
-  digestCommand
-} from "./chunk-7WD63HU2.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-EFHQ3TWP.js";
-import "./chunk-GQ4N4WKF.js";
-import "./chunk-CNUKCS2T.js";
-import "./chunk-S2A7YC3Q.js";
-import "./chunk-D3PO4DOZ.js";
-import "./chunk-TV45EUGM.js";
-export {
-  buildDigest,
-  digestCommand
-};