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

package/dist/chunk-NIYB5K5B.js

@@ -0,0 +1,583 @@
+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 {
+  loadCatalog
+} from "./chunk-BUWSOQLU.js";
+import {
+  repoFor
+} from "./chunk-LDIARP6F.js";
+import {
+  checkDraft,
+  checkFrameworkDraft,
+  draftDialect,
+  draftFramework,
+  evalOnboarding,
+  findGaps,
+  formatEval,
+  learnFrameworkFrom,
+  loadEvalCases,
+  proposalYaml,
+  reviewRepo,
+  surveyRepo
+} from "./chunk-XKJRPVJO.js";
+import {
+  matchRepoType
+} from "./chunk-IILZ7J3L.js";
+import {
+  modelCovers,
+  repoImports,
+  runDialectTests,
+  runFrameworkTests
+} from "./chunk-GVFUEGGM.js";
+import {
+  offerCodeDir
+} from "./chunk-YVCOQ5TZ.js";
+import {
+  baseClonePath
+} from "./chunk-XZJE6WIT.js";
+import {
+  fsRepo
+} from "./chunk-FMRMTI7W.js";
+import {
+  Dialect,
+  FrameworkModel,
+  RecordId,
+  listQuestions,
+  loadOrgPack,
+  orgPackDirOf,
+  questionsRelOf,
+  raiseQuestions,
+  require_dist,
+  reusedLine
+} from "./chunk-JMOLB347.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/onboard-commands.js
+var import_yaml = __toESM(require_dist(), 1);
+import { mkdir, readFile, rename, stat, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+var plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+var proposalPath = (root, name) => join(root, "proposals", "dialects", `${name}.yaml`);
+var isDir = async (p) => !!(await stat(p).catch(() => void 0))?.isDirectory();
+async function onboardDraft(root, target, o, deps, io) {
+  const repo = await repoFor(root, target);
+  if (!repo) {
+    io.err(`${target} isn't a cloned repo of the manifest or a folder; clone it with atticus workspace sync, or give its folder.`);
+    return 2;
+  }
+  const name = o.name ?? repo.id.toLowerCase().replace(/[^a-z0-9._-]+/g, "-");
+  if (!RecordId.safeParse(name).success) {
+    io.err(`"${name}" isn't a dialect name: use lower case, digits and dashes (--name).`);
+    return 2;
+  }
+  const op = await loadOrgPack(orgPackDirOf(root));
+  offerCodeDir(repo.id, repo.dir);
+  const handle = fsRepo(repo.id, repo.dir, "0".repeat(40));
+  const r = await draftDialect(handle, {
+    name,
+    runtime: deps.runtime,
+    orgPack: op,
+    maxAttempts: o.attempts ?? 3,
+    ...deps.now ? { now: deps.now } : {}
+  });
+  const rel = `proposals/dialects/${name}.yaml`;
+  if (r.status === "waiting") {
+    io.out(`Handed to your assistant (run ${r.runId}). Save its dialect as ${rel}, then check it: atticus onboard check ${name} --repo ${repo.id}`);
+    return 0;
+  }
+  for (const a of r.attempts.filter((x) => x.problems.length > 0)) {
+    io.out(`Attempt ${a.attempt}: ${plural(a.problems.length, "problem")}, handed back:`);
+    for (const p of a.problems)
+      io.out(`  - ${p}`);
+  }
+  if (r.status === "failed") {
+    io.err(`No draft passed in ${plural(r.attempts.length, "attempt")}. Nothing was written. Try again with --attempts, give the assistant the framework's documents, or write the dialect with the kit (atticus dialect kit).`);
+    return 1;
+  }
+  await mkdir(join(root, "proposals", "dialects"), { recursive: true });
+  await writeFile(proposalPath(root, name), r.yaml, "utf8");
+  const kinds = /* @__PURE__ */ new Map();
+  for (const x of r.records)
+    kinds.set(x.split(" ")[0], (kinds.get(x.split(" ")[0]) ?? 0) + 1);
+  io.out(`Drafted ${rel} for ${repo.id} in ${plural(r.attempts.length, "attempt")}: its tests pass, and on ${repo.id} it gives ${[...kinds].map(([k, n]) => plural(n, k)).join(", ")}.`);
+  for (const x of r.records)
+    io.out(`  ${x}`);
+  io.out(`It is a proposal: nothing scans with it yet. Review the rules and their tests, then: atticus onboard accept ${name}`);
+  return 0;
+}
+async function onboardCheck(root, name, target, io) {
+  const repo = await repoFor(root, target);
+  if (!repo) {
+    io.err(`${target} isn't a cloned repo of the manifest or a folder.`);
+    return 2;
+  }
+  const text = await readFile(proposalPath(root, name), "utf8").catch(() => void 0);
+  if (text === void 0) {
+    io.err(`There's no proposals/dialects/${name}.yaml.`);
+    return 2;
+  }
+  const c = await checkDraft(text, fsRepo(repo.id, repo.dir, "0".repeat(40)), name);
+  if (c.problems.length) {
+    for (const p of c.problems)
+      io.err(`- ${p}`);
+    return 1;
+  }
+  io.out(`proposals/dialects/${name}.yaml passes: its tests pass, and on ${repo.id} it gives ${plural(c.records.length, "record")}. Accept it: atticus onboard accept ${name}`);
+  return 0;
+}
+async function onboardAccept(root, name, o, io) {
+  const from = proposalPath(root, name);
+  const text = await readFile(from, "utf8").catch(() => void 0);
+  if (text === void 0) {
+    if (await stat(frameworkProposalPath(root, name)).catch(() => void 0))
+      return onboardFrameworkAccept(root, name, o, io);
+    io.err(`There's no proposals/dialects/${name}.yaml or proposals/frameworks/${name}.yaml to accept.`);
+    return 2;
+  }
+  const parsed = Dialect.safeParse((0, import_yaml.parse)(text));
+  if (!parsed.success) {
+    io.err(`proposals/dialects/${name}.yaml isn't a valid dialect; run atticus onboard check.`);
+    return 1;
+  }
+  const failures = await runDialectTests(parsed.data, ".");
+  if (failures.length) {
+    for (const f of failures)
+      io.err(`- test "${f.test}": ${f.message}`);
+    io.err("Its tests fail, so it can't be accepted.");
+    return 1;
+  }
+  const to = join(orgPackDirOf(root), "dialects", `${name}.yaml`);
+  if (await stat(to).catch(() => void 0) && !o.replace) {
+    io.err(`org-pack/dialects/${name}.yaml exists; use --replace to replace it.`);
+    return 1;
+  }
+  await mkdir(join(orgPackDirOf(root), "dialects"), { recursive: true });
+  await rename(from, to);
+  const types = parsed.data.appliesTo.repoTypes;
+  io.out(`Accepted: org-pack/dialects/${name}.yaml. ${types.length ? `It applies to repos of type ${types.join(", ")}.` : `Add it to the repos it reads in repos.manifest.yaml: dialects: [${name}].`} Commit the org pack for review, as with any change to it.`);
+  return 0;
+}
+async function onboardEval(root, dir, o, deps, io) {
+  if (!await isDir(resolve(dir))) {
+    io.err(`${dir} isn't a folder of evaluation cases (each <case>/case.yaml).`);
+    return 2;
+  }
+  const cases = await loadEvalCases(resolve(dir));
+  if (cases.length === 0) {
+    io.err(`${dir} has no cases (each <case>/case.yaml names a repo and a reference dialect).`);
+    return 2;
+  }
+  const op = await loadOrgPack(orgPackDirOf(root));
+  const results = await evalOnboarding(cases, {
+    runtime: deps.runtime,
+    orgPack: op,
+    maxAttempts: o.attempts ?? 3,
+    ...deps.now ? { now: deps.now } : {}
+  });
+  if (o.json)
+    io.out(JSON.stringify(results, null, 2));
+  else
+    for (const l of formatEval(results))
+      io.out(l);
+  return results.every((r) => r.status === "drafted" && r.precision === 1 && r.recall === 1) ? 0 : 1;
+}
+var frameworkProposalPath = (root, name) => join(root, "proposals", "frameworks", `${name}.yaml`);
+async function frameworkUsers(root, op, named, packages, io) {
+  if (named?.length) {
+    const out2 = [];
+    for (const u of named) {
+      const repo = await repoFor(root, u);
+      if (!repo) {
+        io.err(`${u} isn't a cloned repo of the manifest or a folder; clone it with atticus workspace sync, or give its folder.`);
+        return void 0;
+      }
+      out2.push(repo);
+    }
+    return out2;
+  }
+  const out = [];
+  const pk = { packages };
+  for (const r of op.profiles.flatMap((p) => (p.repos?.repos ?? []).filter((x) => !x.archived))) {
+    const dir = baseClonePath(root, r.id);
+    if (!await isDir(dir) || packages.length === 0)
+      continue;
+    const imports = await repoImports(fsRepo(r.id, dir, "0".repeat(40)));
+    if ([...imports.modules.keys()].some((m) => modelCovers(pk, m)))
+      out.push({ id: r.id, dir });
+  }
+  if (out.length === 0) {
+    io.err(`No cloned repo imports ${packages.length ? packages.join(", ") : "the framework"}: name the repos that use it with --users <repo>[,<repo>...].`);
+    return void 0;
+  }
+  return out;
+}
+function reportCheck(c, io) {
+  for (const g of c.gains) {
+    const mine = new Set(c.drafted.find((d) => d.repo === g.repo)?.records ?? []);
+    io.out(`On ${g.repo} it reads ${plural(g.records.length, "record")} the repo doesn't give without it${g.records.length ? ":" : "."}`);
+    for (const l of g.records)
+      io.out(`  ${l}${c.added.length && mine.has(l) ? "  (drafted)" : ""}`);
+  }
+  if (c.idle.length)
+    io.out(`These entries change nothing in these repos: ${c.idle.join(", ")}. Keep them only if other repos use them.`);
+  if (c.added.length)
+    io.out(`Review the drafted entries first (inferred until a person confirms them): ${c.added.map((e) => `${e.label} (${e.source.kind}${e.source.ref ? ` ${e.source.ref}` : ""})`).join("; ")}.`);
+}
+async function onboardFramework(root, name, o, deps, io) {
+  if (!RecordId.safeParse(name).success) {
+    io.err(`"${name}" isn't a framework name: use lower case, digits and dashes, e.g. tide-platform.`);
+    return 2;
+  }
+  const op = await loadOrgPack(orgPackDirOf(root));
+  let learned;
+  if (o.from) {
+    try {
+      learned = await learnFrameworkFrom(o.from, {
+        name,
+        ...o.packages?.length ? { packages: o.packages } : {}
+      });
+    } catch (e) {
+      io.err(`${o.from} couldn't be read (${e.message}): give the framework's source folder, its JAR or its npm package (.tgz).`);
+      return 2;
+    }
+  } else
+    learned = {
+      from: "none",
+      notes: ["no --from was given: the assistant drafts from the repos that use the framework"]
+    };
+  const existing = op.frameworks.find((m) => m.name === name);
+  const packages = [
+    .../* @__PURE__ */ new Set([
+      ...o.packages ?? [],
+      ...learned.model?.packages ?? [],
+      ...existing?.packages ?? []
+    ])
+  ];
+  const users = await frameworkUsers(root, op, o.users, packages, io);
+  if (!users)
+    return 2;
+  const handles = users.map((u) => fsRepo(u.id, u.dir, "0".repeat(40)));
+  const what = learned.from === "jar" ? "its JAR" : learned.from === "package" ? "its npm package" : learned.from === "source" ? "its source" : void 0;
+  if (learned.model && what) {
+    const m = learned.model;
+    io.out(`Learned from ${what}: ${plural(m.annotations.length, "annotation")}, ${plural(m.clients.length + m.calls.length, "call")}, ${plural(m.routes.length, "route")}, ${plural(Object.keys(m.constants).length, "constant")} (verified: no draft changes them).`);
+  }
+  for (const n of learned.notes)
+    io.out(`note: ${n}`);
+  if (!deps.runtime && !learned.model) {
+    io.err("The learner read nothing and AI is off, so there is nothing to propose: write the model with the kit (atticus frameworks kit).");
+    return 1;
+  }
+  const r = await draftFramework({
+    name,
+    learned,
+    users: handles,
+    ...deps.runtime ? { runtime: deps.runtime } : {},
+    orgPack: op,
+    ...o.packages?.length ? { packages: o.packages } : {},
+    ...existing ? { existing } : {},
+    maxAttempts: o.attempts ?? 3,
+    ...deps.now ? { now: deps.now } : {}
+  });
+  const rel = `proposals/frameworks/${name}.yaml`;
+  const userList = users.map((u) => u.id).join(",");
+  const checkCmd = `atticus onboard check framework ${name}${o.from ? ` --from ${o.from}` : ""} --users ${userList}`;
+  if (r.status === "waiting") {
+    if (learned.model) {
+      await mkdir(join(root, "proposals", "frameworks"), { recursive: true });
+      await writeFile(frameworkProposalPath(root, name), proposalYaml(learned.model, []), "utf8");
+    }
+    io.out(`Handed to your assistant (run ${r.runId}). ${learned.model ? `${rel} holds what was learned; the assistant adds to it` : `Save its model as ${rel}`}, then check it: ${checkCmd}`);
+    return 0;
+  }
+  for (const a of r.attempts.filter((x) => x.attempt > 0 && x.problems.length > 0)) {
+    io.out(`Attempt ${a.attempt}: ${plural(a.problems.length, "problem")}, handed back:`);
+    for (const p of a.problems)
+      io.out(`  - ${p}`);
+  }
+  if (r.status === "failed") {
+    if (!deps.runtime)
+      for (const p of r.attempts[0]?.problems ?? [])
+        io.err(`- ${p}`);
+    io.err(deps.runtime ? `No draft passed in ${plural(r.attempts.length, "attempt")}. Nothing was written. Try again with --attempts, give the assistant the framework's documents, or write the model with the kit (atticus frameworks kit).` : "The learned model doesn't pass on these repos, and AI is off. Nothing was written. Complete it with the kit (atticus frameworks kit).");
+    return 1;
+  }
+  await mkdir(join(root, "proposals", "frameworks"), { recursive: true });
+  await writeFile(frameworkProposalPath(root, name), r.yaml, "utf8");
+  const c = r.check;
+  io.out(deps.runtime ? `Drafted ${rel} in ${plural(r.attempts.length, "attempt")}: ${plural(c.added.length, "entry", "entries")} drafted by your assistant over what was learned; its tests pass.` : `Wrote ${rel} from the learner alone (AI off): it reads the repos that use it.`);
+  reportCheck(c, io);
+  io.out(`It is a proposal: nothing scans with it yet. Review it, then: atticus onboard accept framework ${name}${existing ? " --replace (it replaces the model in the org pack)" : ""}`);
+  return 0;
+}
+async function onboardFrameworkCheck(root, name, o, io) {
+  const file = frameworkProposalPath(root, name);
+  const text = await readFile(file, "utf8").catch(() => void 0);
+  if (text === void 0) {
+    io.err(`There's no proposals/frameworks/${name}.yaml.`);
+    return 2;
+  }
+  const op = await loadOrgPack(orgPackDirOf(root));
+  let learned;
+  if (o.from) {
+    try {
+      learned = (await learnFrameworkFrom(o.from, {
+        name,
+        ...o.packages?.length ? { packages: o.packages } : {}
+      })).model;
+    } catch (e) {
+      io.err(`${o.from} couldn't be read (${e.message}).`);
+      return 2;
+    }
+  }
+  let packages = [...o.packages ?? [], ...learned?.packages ?? []];
+  try {
+    packages.push(...(0, import_yaml.parse)(text)?.packages ?? []);
+  } catch {
+  }
+  packages = [...new Set(packages.filter((p) => typeof p === "string"))];
+  const users = await frameworkUsers(root, op, o.users, packages, io);
+  if (!users)
+    return 2;
+  const c = await checkFrameworkDraft(text, {
+    name,
+    ...learned ? { learned } : {},
+    users: users.map((u) => fsRepo(u.id, u.dir, "0".repeat(40))),
+    others: op.frameworks
+  });
+  if (c.problems.length) {
+    for (const p of c.problems)
+      io.err(`- ${p}`);
+    if (!o.from && c.problems.some((p) => /source (code|bytecode) is only for/.test(p)))
+      io.err("Entries citing code or bytecode are confirmed by reading the framework again: give --from <its source, JAR or package>.");
+    return 1;
+  }
+  const merged = proposalYaml(c.model, c.added);
+  if (learned && merged !== text)
+    await writeFile(file, merged, "utf8");
+  io.out(`proposals/frameworks/${name}.yaml passes${learned && merged !== text ? " (rewritten with what the learner read)" : ""}: its tests pass, and it reads the repos that use it.`);
+  reportCheck(c, io);
+  io.out(`Accept it: atticus onboard accept framework ${name}`);
+  return 0;
+}
+async function onboardFrameworkAccept(root, name, o, io) {
+  const from = frameworkProposalPath(root, name);
+  const text = await readFile(from, "utf8").catch(() => void 0);
+  if (text === void 0) {
+    io.err(`There's no proposals/frameworks/${name}.yaml to accept.`);
+    return 2;
+  }
+  let model;
+  try {
+    model = FrameworkModel.parse((0, import_yaml.parse)(text));
+  } catch {
+    io.err(`proposals/frameworks/${name}.yaml isn't a valid framework model; run atticus onboard check framework ${name}.`);
+    return 1;
+  }
+  const failures = await runFrameworkTests(model);
+  if (failures.length) {
+    for (const f of failures)
+      io.err(`- test "${f.test}": ${f.message}`);
+    io.err("Its tests fail, so it can't be accepted.");
+    return 1;
+  }
+  const to = join(orgPackDirOf(root), "frameworks", `${name}.yaml`);
+  if (await stat(to).catch(() => void 0) && !o.replace) {
+    io.err(`org-pack/frameworks/${name}.yaml exists; use --replace to replace it.`);
+    return 1;
+  }
+  await mkdir(join(orgPackDirOf(root), "frameworks"), { recursive: true });
+  await rename(from, to);
+  io.out(`Accepted: org-pack/frameworks/${name}.yaml. Scans read every repo that imports ${model.packages.join(", ")} through it. Commit the org pack for review, as with any change to it.`);
+  return 0;
+}
+async function matchedRepoType(repo, id, op, io) {
+  if (op.repoTypes.length === 0)
+    return void 0;
+  const m = await matchRepoType(repo, op.repoTypes);
+  if (m.verdict === "tie") {
+    io.out(`${id} matches ${m.tied.join(" and ")} about as well, so the survey uses neither. See atticus repo-type detect ${id}.`);
+    return void 0;
+  }
+  if (m.verdict === "none")
+    return void 0;
+  const type = op.repoTypes.find((t) => t.id === m.best);
+  const score = m.matches[0].score;
+  io.out(`${id} is a ${m.verdict} match for the repo type ${type.id} (${Math.round(score * 100)}%); its settings and skills go to your assistant.`);
+  const skills = op.skills.filter((s) => type.skills.includes(`process/skills/${s.id}/SKILL.md`));
+  return { type, verdict: m.verdict, score, skills };
+}
+async function scanSurvey(root, target, o, deps, io) {
+  const repo = await repoFor(root, target);
+  if (!repo) {
+    io.err(`${target} isn't a cloned repo of the manifest or a folder; clone it with atticus workspace sync, or give its folder.`);
+    return 2;
+  }
+  const file = join(orgPackDirOf(root), "scan", `${repo.id}.yaml`);
+  if (!o.force && !o.resume && await stat(file).catch(() => void 0)) {
+    io.err(`${repo.id} already has scan settings (org-pack/scan/${repo.id}.yaml). Re-run with --force to draft them again.`);
+    return 1;
+  }
+  const op = await loadOrgPack(orgPackDirOf(root));
+  const before = await listQuestions(root, { repo: repo.id, step: "scan-survey" });
+  offerCodeDir(repo.id, repo.dir);
+  const handle = fsRepo(repo.id, repo.dir, "0".repeat(40));
+  const repoType = await matchedRepoType(handle, repo.id, op, io);
+  const r = await surveyRepo(handle, {
+    repoId: repo.id,
+    runtime: deps.runtime,
+    orgPack: op,
+    ...repoType ? { repoType } : {},
+    maxAttempts: o.attempts ?? 3,
+    questions: before.questions,
+    ...deps.now ? { now: deps.now } : {},
+    ...o.resume ? { resume: o.resume } : {}
+  });
+  if (r.status === "waiting") {
+    io.out(`Handed the survey to your assistant (run ${r.runId}). When it is done: atticus handoff done ${r.runId}, then atticus scan survey ${repo.id} --resume ${r.runId}`);
+    return 0;
+  }
+  for (const a of r.attempts.filter((x) => x.problems.length > 0)) {
+    io.out(`Attempt ${a.attempt}: ${plural(a.problems.length, "problem")}, handed back:`);
+    for (const p of a.problems)
+      io.out(`  - ${p}`);
+  }
+  if (r.status !== "drafted" || !r.settings) {
+    io.out(`The survey still had problems after ${plural(r.attempts.length, "attempt")}; nothing was written.`);
+    return 1;
+  }
+  await mkdir(join(orgPackDirOf(root), "scan"), { recursive: true });
+  await writeFile(file, `# Drafted by atticus scan survey on ${(deps.now ?? /* @__PURE__ */ new Date()).toISOString().slice(0, 10)}; every entry was checked against the code (ADR 0075). Review it like any org-pack change.
+${r.yaml}`, "utf8");
+  const s = r.settings;
+  io.out(`Wrote org-pack/scan/${repo.id}.yaml: ${plural(s.exclude.length, "folder")} left out, ${plural(s.prefixes.length, "prefix", "prefixes")}${s.clients.length ? `, ${plural(s.clients.length, "client base")}` : ""}.`);
+  for (const e of s.exclude)
+    io.out(`  leave out ${e.path}: ${e.why} (${e.at})`);
+  for (const p of s.prefixes)
+    io.out(`  ${p.prefix} in front of ${p.paths.join(", ")}: ${p.why} (${p.at})`);
+  for (const c of s.clients)
+    io.out(`  ${c.base} in front of the calls in ${c.paths.join(", ")}: ${c.why} (${c.at})`);
+  const rerun = `atticus scan survey ${repo.id} --force`;
+  const { raised, known, reused } = await raiseQuestions(root, r.questions ?? [], {
+    step: "scan-survey",
+    repo: repo.id,
+    command: `atticus scan survey ${repo.id}`,
+    rerun,
+    ...r.runId ? { run: r.runId } : {},
+    at: (deps.now ?? /* @__PURE__ */ new Date()).toISOString()
+  });
+  const waiting = known.filter((q) => q.state === "open");
+  if (raised.length) {
+    io.out(`${plural(raised.length, "question")} for a person, in ${questionsRelOf(root)}/:`);
+    for (const q of raised)
+      io.out(`  ${q.id} ${q.question}`);
+  }
+  for (const q of reused)
+    io.out(reusedLine(q));
+  if (waiting.length)
+    io.out(`${plural(waiting.length, "question")} still waiting for an answer: ${waiting.map((q) => q.id).join(", ")}`);
+  if (raised.length + waiting.length === 0)
+    io.out(`Next: atticus scan, then review the file in a pull request.`);
+  else
+    io.out(`Answer ${raised.length + waiting.length === 1 ? "it" : "them"} with atticus questions answer <id> --option <n>, or on the app's Questions page; then run ${rerun}`);
+  return 0;
+}
+async function scanReview(root, target, o, deps, io) {
+  const repo = await repoFor(root, target);
+  if (!repo) {
+    io.err(`${target} isn't a cloned repo of the manifest or a folder; clone it with atticus workspace sync, or give its folder.`);
+    return 2;
+  }
+  const name = o.name ?? `${repo.id.toLowerCase().replace(/[^a-z0-9._-]+/g, "-")}-review`;
+  if (!RecordId.safeParse(name).success) {
+    io.err(`"${name}" isn't a dialect name: use lower case, digits and dashes (--name).`);
+    return 2;
+  }
+  const { records } = await loadCatalog(root, { out: () => {
+  }, err: (l) => io.err(l) });
+  offerCodeDir(repo.id, repo.dir);
+  const handle = fsRepo(repo.id, repo.dir, "0".repeat(40));
+  const gaps = await findGaps(handle, records);
+  if (gaps.length === 0) {
+    io.out(`The last scan of ${repo.id} left no gaps: everything it found is read and resolved.`);
+    return 0;
+  }
+  io.out(`${plural(gaps.length, "gap")} in ${repo.id} after the last scan:`);
+  for (const g of gaps)
+    io.out(`  ${g.id} ${g.kind} ${g.path}${g.line ? `:${g.line}` : ""}${g.raw ? ` ${g.raw}` : ""}${g.component ? ` (${g.component})` : ""}`);
+  if (o.gapsOnly)
+    return 0;
+  const op = await loadOrgPack(orgPackDirOf(root));
+  const r = await reviewRepo(handle, {
+    name,
+    runtime: deps.runtime,
+    gaps,
+    orgPack: op,
+    maxAttempts: o.attempts ?? 3,
+    ...deps.now ? { now: deps.now } : {},
+    ...o.resume ? { resume: o.resume } : {}
+  });
+  if (r.status === "waiting") {
+    io.out(`Handed the gaps to your assistant (run ${r.runId}). When it is done: atticus handoff done ${r.runId}, then atticus scan review ${repo.id} --resume ${r.runId}`);
+    return 0;
+  }
+  for (const a of r.attempts.filter((x) => x.problems.length > 0)) {
+    io.out(`Attempt ${a.attempt}: ${plural(a.problems.length, "problem")}, handed back:`);
+    for (const p of a.problems)
+      io.out(`  - ${p}`);
+  }
+  if (r.status === "failed") {
+    io.err(`No answer passed in ${plural(r.attempts.length, "attempt")}. Nothing was written.`);
+    return 1;
+  }
+  io.out("Verdicts:");
+  for (const v of r.verdicts)
+    io.out(`  ${v.gap} ${v.verdict}: ${v.why}`);
+  const report = [
+    `# Scan review of ${repo.id}`,
+    "",
+    "Drafted by atticus scan review from the gaps the last scan left; a person decides on each.",
+    "",
+    "| Gap | Kind | Where | Verdict | Why |",
+    "| --- | --- | --- | --- | --- |",
+    ...gaps.map((g) => {
+      const v = r.verdicts.find((x) => x.gap === g.id);
+      const where = `${g.path}${g.line ? `:${g.line}` : ""}${g.raw ? ` (${g.raw})` : ""}`;
+      return `| ${g.id} | ${g.kind} | ${where.replace(/\|/g, "\\|")} | ${v?.verdict ?? ""} | ${(v?.why ?? "").replace(/\|/g, "\\|")} |`;
+    }),
+    ""
+  ].join("\n");
+  await mkdir(join(root, "proposals", "reviews"), { recursive: true });
+  await writeFile(join(root, "proposals", "reviews", `${repo.id}.md`), report, "utf8");
+  io.out(`Wrote proposals/reviews/${repo.id}.md.`);
+  if (r.yaml) {
+    await mkdir(join(root, "proposals", "dialects"), { recursive: true });
+    await writeFile(proposalPath(root, name), r.yaml, "utf8");
+    io.out(`Drafted proposals/dialects/${name}.yaml: its tests pass, and it reads ${plural(r.resolved.length, "gap")} (${r.resolved.join(", ")}) with ${plural(r.records.length, "record")}. Review it, then: atticus onboard accept ${name}, and atticus scan.`);
+  }
+  const misread = r.verdicts.filter((v) => v.verdict === "reader");
+  if (misread.length)
+    io.out(`For Atticus: ${plural(misread.length, "gap")} where a built-in reader misreads the code (${misread.map((v) => v.gap).join(", ")}); the review file says what each misreads.`);
+  const others = r.verdicts.filter((v) => v.verdict === "vendor" || v.verdict === "person");
+  if (others.length)
+    io.out(`For a person: ${others.map((v) => `${v.gap} (${v.verdict})`).join(", ")}. Record a vendor with atticus alias, or answer in the review file.`);
+  return 0;
+}
+
+export {
+  onboardDraft,
+  onboardCheck,
+  onboardAccept,
+  onboardEval,
+  onboardFramework,
+  onboardFrameworkCheck,
+  onboardFrameworkAccept,
+  matchedRepoType,
+  scanSurvey,
+  scanReview
+};

package/dist/chunk-NR5T46ZY.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-NIYB5K5B.js";
+import "./chunk-BUWSOQLU.js";
+import {
+  repoFor
+} from "./chunk-LDIARP6F.js";
+import "./chunk-XKJRPVJO.js";
+import "./chunk-IILZ7J3L.js";
+import "./chunk-TEBBD4XH.js";
+import "./chunk-XPWSNKF3.js";
+import "./chunk-WIMOJMAK.js";
+import "./chunk-5V5BJACL.js";
+import "./chunk-GVFUEGGM.js";
+import "./chunk-YVCOQ5TZ.js";
+import "./chunk-XNRPCI23.js";
+import "./chunk-XZJE6WIT.js";
+import "./chunk-FMRMTI7W.js";
+import "./chunk-BKFGGJKA.js";
+import "./chunk-JMOLB347.js";
+import "./chunk-MMB2OHUY.js";
+import "./chunk-TV45EUGM.js";
+export {
+  matchedRepoType,
+  onboardAccept,
+  onboardCheck,
+  onboardDraft,
+  onboardEval,
+  onboardFramework,
+  onboardFrameworkAccept,
+  onboardFrameworkCheck,
+  repoFor,
+  scanReview,
+  scanSurvey
+};