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

package/dist/chunk-F44OMYIN.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-N3E56YPN.js";
+import "./chunk-Z7SG32ZY.js";
+import "./chunk-DPC5Y5DL.js";
+import "./chunk-RZUZ4RJJ.js";
+import "./chunk-L3BX5ZIB.js";
+import "./chunk-OW7D2PJL.js";
+import "./chunk-BWZ77RQT.js";
+import "./chunk-ZJSP24X4.js";
+import "./chunk-6SCVQZX5.js";
+import "./chunk-65NYPGRC.js";
+import "./chunk-VOGCSYOI.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 {
+  completionOf,
+  handoffDone,
+  openspecCheck,
+  openspecSetup,
+  workspaceOpen,
+  workspacePrune,
+  workspaceSync
+};

package/dist/chunk-F7HYOUFF.js

@@ -0,0 +1,287 @@
+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 {
+  aliasArgv,
+  isLegacy
+} from "./chunk-ZDPAS56H.js";
+import {
+  isHandoffStep
+} from "./chunk-4Q3NN7VF.js";
+
+// packages/cli/dist/command-catalog.js
+var AREAS = [
+  { id: "start", title: "Set up and keep healthy" },
+  { id: "repos", title: "Repos, scans and specs" },
+  { id: "knowledge", title: "Knowledge and documents" },
+  { id: "catalog", title: "The catalog" },
+  { id: "changes", title: "Changes, findings and questions" },
+  { id: "plan", title: "Plans, tasks and work items" },
+  { id: "release", title: "Release" },
+  { id: "developer", title: "For Atticus's own quality" }
+];
+var AREA_BY_WORD = {
+  init: "start",
+  adopt: "start",
+  unadopt: "start",
+  setup: "start",
+  doctor: "start",
+  probe: "start",
+  secret: "start",
+  upgrade: "start",
+  support: "start",
+  sandbox: "start",
+  learn: "start",
+  explain: "start",
+  executors: "start",
+  openspec: "start",
+  "assistant-files": "start",
+  ui: "start",
+  mcp: "start",
+  index: "start",
+  schema: "start",
+  orgpack: "start",
+  templates: "start",
+  commands: "start",
+  legacy: "start",
+  next: "changes",
+  scan: "repos",
+  verify: "repos",
+  join: "repos",
+  map: "repos",
+  spec: "repos",
+  estate: "repos",
+  "repo-type": "repos",
+  repo: "repos",
+  repos: "repos",
+  workspace: "repos",
+  frameworks: "repos",
+  dialect: "repos",
+  onboard: "repos",
+  baseline: "repos",
+  drift: "repos",
+  stub: "repos",
+  ci: "repos",
+  sources: "knowledge",
+  standards: "knowledge",
+  knowledge: "knowledge",
+  patterns: "knowledge",
+  absorb: "knowledge",
+  intake: "knowledge",
+  triage: "knowledge",
+  glossary: "knowledge",
+  domain: "knowledge",
+  catalog: "catalog",
+  query: "catalog",
+  context: "catalog",
+  cites: "catalog",
+  impact: "catalog",
+  ask: "catalog",
+  guide: "catalog",
+  diagram: "catalog",
+  reconcile: "catalog",
+  coverage: "catalog",
+  feature: "catalog",
+  alias: "catalog",
+  site: "catalog",
+  digest: "changes",
+  change: "changes",
+  finding: "changes",
+  findings: "changes",
+  stage: "changes",
+  critic: "changes",
+  handoff: "changes",
+  questions: "changes",
+  plan: "plan",
+  task: "plan",
+  stories: "plan",
+  todo: "plan",
+  needs: "changes",
+  waiting: "changes",
+  watch: "changes",
+  runs: "changes",
+  history: "changes",
+  ado: "plan",
+  tests: "plan",
+  trace: "plan",
+  initiative: "plan",
+  outcome: "plan",
+  release: "release",
+  bench: "developer",
+  eval: "developer",
+  defences: "developer",
+  plugin: "developer",
+  conformance: "developer"
+};
+var AREA_BY_ID = {
+  "spec hand-down": "changes",
+  "spec hand-up": "changes",
+  "ci archive-gate": "release"
+};
+var KIND_BY_NAME = {
+  repo: "repo",
+  repos: "repo",
+  change: "change",
+  flow: "flow",
+  system: "system",
+  file: "path",
+  files: "path",
+  dir: "path",
+  path: "path",
+  a: "path",
+  b: "path"
+};
+var KIND_BY_COMMAND = {
+  "questions answer": ["question"],
+  "change status": ["change"],
+  "change handoff": ["change"],
+  "change sync": ["change"],
+  "change return": ["change"],
+  "change archive": ["change"],
+  finding: ["change", "finding"],
+  findings: ["change"],
+  impact: ["record"],
+  drift: ["change"],
+  trace: ["change"]
+};
+var SERVES = /* @__PURE__ */ new Set(["ui", "stub serve", "mcp"]);
+var APPROVE_FLAGS = ["--approve", "--send"];
+var isWord = (t) => /^[a-z][a-z-]*$/.test(t);
+function parseArgs(id, usage) {
+  const out = [];
+  const kinds = KIND_BY_COMMAND[id];
+  const re = /(\[|"?<)([a-z][a-z|-]*?)(\.\.\.)?(>"?|\])(\.\.\.)?/g;
+  for (const m of usage.matchAll(re)) {
+    const before = usage.slice(0, m.index).trimEnd();
+    if (/--[a-z-]+$/.test(before) || /--[a-z-]+ ?\|?$/.test(before))
+      continue;
+    if (m[1] === "[" && !/^[a-z]+$/.test(m[2]))
+      continue;
+    const raw = m[2];
+    const parts = raw.split("|");
+    const isChoice = parts.length >= 3;
+    const name = isChoice ? "choice" : parts[0];
+    const kind = kinds?.[out.length] ?? (isChoice ? "choice" : KIND_BY_NAME[name] ?? "text");
+    out.push({
+      name,
+      kind,
+      optional: m[1] === "[",
+      many: !!(m[3] || m[5]),
+      ...isChoice ? { choices: parts } : {}
+    });
+  }
+  return out;
+}
+function parseFlags(text, summaries) {
+  const out = /* @__PURE__ */ new Map();
+  const re = /(--[a-z][a-z-]*)(?:[ =]("[^"]*"|<[^>]+>|[A-Za-z0-9][\w.,=-]*(?:\|[\w.-]+)*))?/g;
+  for (const m of text.matchAll(re)) {
+    const name = m[1];
+    if (out.has(name))
+      continue;
+    const before = text.slice(0, m.index);
+    const opened = (before.match(/\[/g) ?? []).length - (before.match(/\]/g) ?? []).length;
+    let value = m[2]?.replace(/^<|>$/g, "");
+    if (value?.startsWith("--") || value && /^[a-z]+$/.test(value) && !m[2].startsWith("<"))
+      value = /^(m|n|t|s|k|f|c|d|o|p|file|dir|id)$/.test(value) ? value : void 0;
+    const summary = summaries.get(name);
+    out.set(name, {
+      name,
+      ...value ? { value } : {},
+      // `<folder> | --org <org>`: the option is given instead of the argument, not as well.
+      required: opened <= 0 && !/<[^>]+>\s*\|\s*$/.test(before),
+      ...summary ? { summary } : {}
+    });
+  }
+  return [...out.values()];
+}
+function parseHelp(help) {
+  const out = [];
+  let current;
+  const blocks = [];
+  for (const l of help.split("\n")) {
+    if (/^ {2}atticus /.test(l)) {
+      current = { line: l.trim(), more: [] };
+      blocks.push(current);
+    } else if (current && /^ {6,}\[?--|^ {6,}\(/.test(l))
+      current.more.push(l.trim());
+    else if (current && !current.more.length && current.below === void 0 && /^ {6,}\S/.test(l))
+      current.below = l.trim();
+    else if (!/^ {6,}/.test(l))
+      current = void 0;
+  }
+  for (const b of blocks) {
+    if (/^atticus (--help|--version|<step>)/.test(b.line))
+      continue;
+    const cut = b.line.search(/ {2,}/);
+    const usage = cut > 0 ? b.line.slice(0, cut) : b.line;
+    const written = cut > 0 ? b.line.slice(cut).trim() : b.below ?? "";
+    const summary = written.replace(/(\s*\[[^\]]*--[^\]]*\](\.\.\.)?)+\s*$/, "");
+    const tokens = usage.split(" ").slice(1);
+    const words = [];
+    for (const t of tokens) {
+      if (!isWord(t))
+        break;
+      words.push(t);
+    }
+    const id = words.join(" ");
+    const summaries = /* @__PURE__ */ new Map();
+    for (const m of b.more) {
+      const c = m.search(/ {2,}/);
+      const opt = c > 0 ? m.slice(0, c) : m;
+      const what = c > 0 ? m.slice(c).trim() : "";
+      for (const f of opt.matchAll(/--[a-z][a-z-]*/g))
+        if (what)
+          summaries.set(f[0], what);
+    }
+    const optionText = [
+      usage,
+      written,
+      // Each option line's option part only: its description may hold brackets of its own.
+      ...b.more.map((m) => {
+        const c = m.search(/ {2,}/);
+        return `[${(c > 0 ? m.slice(0, c) : m).replace(/^\[|\]$/g, "")}]`;
+      })
+    ].join(" ");
+    out.push({
+      id,
+      words,
+      usage,
+      summary,
+      args: parseArgs(id, usage.slice(`atticus ${id}`.length)),
+      flags: parseFlags(optionText, summaries)
+    });
+  }
+  return out;
+}
+function commandCatalog(help) {
+  const seen = /* @__PURE__ */ new Set();
+  return parseHelp(help).map((parsed) => {
+    let c = parsed;
+    if (seen.has(c.id)) {
+      const mark = c.flags.find((f) => f.required) ?? c.flags[0];
+      if (mark)
+        c = { ...c, id: `${c.id} ${mark.name}` };
+    }
+    seen.add(c.id);
+    const area = AREA_BY_ID[c.id] ?? AREA_BY_WORD[c.words[0] ?? ""] ?? "";
+    const approve = APPROVE_FLAGS.find((f) => c.flags.some((x) => x.name === f));
+    const [w0, w1] = aliasArgv(c.words, c.words.map((_, i) => i));
+    const runs = isHandoffStep(w0, w1) || c.id === "critic" || c.id === "map" ? "ai" : SERVES.has(c.id) ? "serve" : approve ? "shared" : "local";
+    return {
+      ...c,
+      area,
+      runs,
+      ...approve && runs === "shared" ? { approve } : {},
+      legacy: isLegacy(c.words[0])
+    };
+  });
+}
+
+export {
+  AREAS,
+  parseHelp,
+  commandCatalog
+};

package/dist/chunk-FALXWAMD.js

@@ -0,0 +1,182 @@
+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 {
+  runPluginTests
+} from "./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-KJPMEAI4.js";
+import {
+  pluginEntryHash,
+  runTranslator
+} from "./chunk-GQ4N4WKF.js";
+import {
+  SHIPPED_MODEL_PROVIDER_PLUGINS
+} from "./chunk-YEDDOYSC.js";
+import "./chunk-CNUKCS2T.js";
+import {
+  ModelProviderPlugin,
+  ScannerPlugin,
+  orgPackDirOf,
+  require_dist
+} from "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/plugin-commands.js
+var import_yaml = __toESM(require_dist(), 1);
+import { existsSync } from "node:fs";
+import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { isDeepStrictEqual } from "node:util";
+var plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+var MODEL_PROVIDERS = "model-providers";
+async function folders(dir) {
+  return (await readdir(dir, { withFileTypes: true }).catch(() => [])).filter((e) => e.isDirectory()).map((e) => e.name);
+}
+async function load(root, id, io) {
+  const plugins = join(orgPackDirOf(root), "plugins");
+  const asModel = join(plugins, MODEL_PROVIDERS, id);
+  const kind = id !== MODEL_PROVIDERS && existsSync(join(plugins, id, "plugin.yaml")) ? "scanner" : existsSync(join(asModel, "plugin.yaml")) ? "model-provider" : void 0;
+  if (!kind) {
+    const known = [
+      ...(await folders(plugins)).filter((n) => n !== MODEL_PROVIDERS),
+      ...await folders(join(plugins, MODEL_PROVIDERS))
+    ].sort();
+    io.err(`No plugin ${id} in org-pack/plugins/ or org-pack/plugins/${MODEL_PROVIDERS}/. ${known.length ? `Plugins here: ${known.join(", ")}` : "This org pack has no plugins yet."}`);
+    return void 0;
+  }
+  const dir = kind === "scanner" ? join(plugins, id) : asModel;
+  const rel = kind === "scanner" ? `plugins/${id}` : `plugins/${MODEL_PROVIDERS}/${id}`;
+  const file = join(dir, "plugin.yaml");
+  let data;
+  try {
+    data = (0, import_yaml.parse)(await readFile(file, "utf8"));
+  } catch (e) {
+    io.err(`org-pack/${rel}/plugin.yaml isn't valid YAML: ${e.message}`);
+    return void 0;
+  }
+  const r = kind === "scanner" ? ScannerPlugin.safeParse(data) : ModelProviderPlugin.safeParse(data);
+  if (!r.success) {
+    io.err(`org-pack/${rel}/plugin.yaml isn't a valid plugin manifest (contract C6):`);
+    for (const i of r.error.issues)
+      io.err(`  ${i.path.length ? `${i.path.map(String).join(".")}: ` : ""}${i.message}`);
+    return void 0;
+  }
+  if (r.data.id !== id) {
+    io.err(`org-pack/${rel}/plugin.yaml is for ${r.data.id}; keep it in a folder of that name`);
+    return void 0;
+  }
+  let source;
+  try {
+    source = await readFile(join(dir, ...r.data.entry.split("/")), "utf8");
+  } catch {
+    io.err(`Can't read the entry file org-pack/${rel}/${r.data.entry}.`);
+    return void 0;
+  }
+  return kind === "scanner" ? { kind, dir, file, rel, source, manifest: r.data } : { kind, dir, file, rel, source, manifest: r.data };
+}
+async function modelProviderTests(p) {
+  const code = {
+    id: p.manifest.id,
+    version: p.manifest.version,
+    source: p.source,
+    entry: p.manifest.entry,
+    limits: p.manifest.limits
+  };
+  const out = [];
+  for (const name of (await folders(join(p.dir, "test"))).sort()) {
+    const at = join(p.dir, "test", name);
+    const failures = [];
+    for (const [fn, given, wanted] of [
+      ["request", "request.json", "expected-request.json"],
+      ["response", "answer.json", "expected-answer.json"]
+    ]) {
+      if (!existsSync(join(at, given)))
+        continue;
+      try {
+        const arg = JSON.parse(await readFile(join(at, given), "utf8"));
+        const expected = JSON.parse(await readFile(join(at, wanted), "utf8"));
+        const got = await runTranslator(code, fn, arg);
+        if (!isDeepStrictEqual(got, expected))
+          failures.push(`${fn} gave ${JSON.stringify(got)}, but ${wanted} says ${JSON.stringify(expected)}`);
+      } catch (e) {
+        failures.push(`${fn}: ${e.message}`);
+      }
+    }
+    out.push({ name, failures });
+  }
+  return out;
+}
+async function pluginTest(root, id, io) {
+  const p = await load(root, id, io);
+  if (!p)
+    return 1;
+  const results = p.kind === "scanner" ? await runPluginTests(p.dir, p.manifest, p.source) : await modelProviderTests(p);
+  io.out(`Testing plugin ${p.manifest.id} ${p.manifest.version}: ${plural(results.length, "test")}`);
+  if (results.length === 0) {
+    io.out(p.kind === "scanner" ? `No tests. Add test/<case>/repo/ and test/<case>/expected.yaml under org-pack/${p.rel}/; the scan won't use a plugin without them.` : `No tests. Add test/<case>/request.json with expected-request.json, and answer.json with expected-answer.json, under org-pack/${p.rel}/.`);
+    return 1;
+  }
+  for (const r of results) {
+    io.out(`  ${r.failures.length === 0 ? "pass" : "FAIL"}  ${r.name}`);
+    for (const f of r.failures)
+      io.out(`          ${f}`);
+  }
+  const hash = pluginEntryHash(p.source);
+  const user = p.kind === "scanner" ? "the scan" : "model mode";
+  const pin = !p.manifest.sha256 ? `It isn't pinned: once it is reviewed, run atticus plugin pin ${id}.` : p.manifest.sha256 === hash ? `The pin matches ${p.manifest.entry}.` : `${p.manifest.entry} changed since it was pinned: ${user} won't use it until it is reviewed and pinned again.`;
+  const failed = results.filter((r) => r.failures.length > 0).length;
+  if (failed === 0) {
+    io.out(`${plural(results.length, "test")} passed. ${pin}`);
+    return 0;
+  }
+  io.out(`${failed} of ${plural(results.length, "test")} failed. ${pin}`);
+  return 1;
+}
+async function pluginPin(root, id, io) {
+  const p = await load(root, id, io);
+  if (!p)
+    return 1;
+  const hash = pluginEntryHash(p.source);
+  const doc = (0, import_yaml.parseDocument)(await readFile(p.file, "utf8"));
+  doc.set("sha256", hash);
+  await writeFile(p.file, doc.toString({ flowCollectionPadding: false }), "utf8");
+  io.out(`Pinned ${p.manifest.id} ${p.manifest.version}: ${p.manifest.entry} has sha256 ${hash}.`);
+  io.out("Commit plugin.yaml with the code, in the same reviewed change.");
+  return 0;
+}
+async function pluginAdd(root, id, io) {
+  const files = SHIPPED_MODEL_PROVIDER_PLUGINS[id];
+  if (!files) {
+    io.err(`Atticus ships no plugin called ${id}. It ships: ${Object.keys(SHIPPED_MODEL_PROVIDER_PLUGINS).sort().join(", ")}.`);
+    return 2;
+  }
+  const dir = join(orgPackDirOf(root), "plugins", MODEL_PROVIDERS, id);
+  if (existsSync(dir)) {
+    io.err(`org-pack/plugins/${MODEL_PROVIDERS}/${id}/ is already there; Atticus leaves it as it is.`);
+    return 1;
+  }
+  for (const [path, text] of Object.entries(files)) {
+    const to = join(dir, ...path.split("/"));
+    await mkdir(dirname(to), { recursive: true });
+    await writeFile(to, text, "utf8");
+  }
+  io.out(`Added the ${id} model-provider plugin in org-pack/plugins/${MODEL_PROVIDERS}/${id}/.`);
+  io.out(`Review index.js: it only builds each request and reads each answer; Atticus makes the call, to the hosts plugin.yaml names, and adds the key itself.`);
+  io.out(`Then run atticus plugin test ${id}, atticus plugin pin ${id}, and commit the folder through a pull request. Choose it as the model provider on Set up \u203A AI (adapters.model.type: ${id}).`);
+  return 0;
+}
+export {
+  pluginAdd,
+  pluginPin,
+  pluginTest
+};

package/dist/chunk-FBNPE7HS.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-5A5L3T2U.js";
+import "./chunk-2UIQBDJO.js";
+import {
+  repoFor
+} from "./chunk-CMV7TGU6.js";
+import "./chunk-DPC5Y5DL.js";
+import "./chunk-ZVM6AKKM.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 {
+  matchedRepoType,
+  onboardAccept,
+  onboardCheck,
+  onboardDraft,
+  onboardEval,
+  onboardFramework,
+  onboardFrameworkAccept,
+  onboardFrameworkCheck,
+  repoFor,
+  scanReview,
+  scanSurvey
+};

package/dist/chunk-FSWUD5QB.js

@@ -0,0 +1,108 @@
+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 {
+  ConformError,
+  conformChange,
+  conformanceOf
+} 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";
+
+// packages/cli/dist/change-conform.js
+var CITE = (c) => `${c.repo ? `${c.repo}:` : ""}${c.path}${c.line ? `:${c.line}` : ""}`;
+var LABEL = {
+  found: "found",
+  missing: "MISSING",
+  "still-there": "STILL THERE",
+  unexpected: "NOT IN THE DESIGN"
+};
+function print(results, io) {
+  for (const r of results) {
+    const n = r.counts;
+    io.out(`${r.repo} at ${r.ref} (${r.commit.slice(0, 12)}, from ${r.base.slice(0, 12)})${r.task ? `, task ${r.task}` : ""}: ${n.found} found, ${n.missing} missing, ${n.stillThere} still there, ${n.unexpected} not in the design.`);
+    for (const i of r.items)
+      io.out(`  ${LABEL[i.status]}  ${i.what}  ${i.at.map(CITE).join(", ")}${i.finding && i.finding.state !== "open" ? ` (${i.finding.state})` : ""}`);
+    if (r.unchecked.length) {
+      io.out("  Not checked by a scan (a person or a test checks these):");
+      for (const u of r.unchecked)
+        io.out(`    ${u.flow}${u.item ? ` item ${u.item}` : " trigger"} (${u.kind}): ${u.why}`);
+    }
+    for (const p of r.problems)
+      io.err(`${r.repo}: ${p}`);
+  }
+}
+async function changeConformCommand(root, change, o, io) {
+  if (o.latest) {
+    const v = await conformanceOf(root, change);
+    if (!v) {
+      io.err(`There is no change ${change}.`);
+      return 2;
+    }
+    if (o.json) {
+      io.out(JSON.stringify(v, null, 2));
+      return 0;
+    }
+    for (const p of v.problems)
+      io.err(p);
+    if (!v.results.length)
+      io.out(v.flows ? `${change} hasn't been checked against its target flows yet: atticus change conform ${change}.` : `${change} has no target flows yet, so there is nothing to check the code against.`);
+    print(v.results, io);
+    return 0;
+  }
+  try {
+    const run = await conformChange(root, change, {
+      ...o.repo ? { repo: o.repo } : {},
+      ...o.ref ? { ref: o.ref } : {},
+      ...o.task ? { task: o.task } : {}
+    });
+    const bad = run.results.some((r) => r.counts.missing + r.counts.stillThere + r.counts.unexpected > 0);
+    if (o.json) {
+      io.out(JSON.stringify(await conformanceOf(root, change), null, 2));
+      return run.results.length && !bad ? 0 : 1;
+    }
+    for (const p of run.problems)
+      io.err(p);
+    if (!run.flows) {
+      io.err(`${change} has no target flows yet, so there is nothing to check the code against: the architecture stage writes them (atticus change architecture ${change}).`);
+      return 1;
+    }
+    if (!run.results.length)
+      return 1;
+    print(run.results, io);
+    io.out(bad ? `The findings are on the conform gate${run.round ? ` (round ${run.round})` : ""}: atticus findings ${change} lists them; dismiss one with atticus finding ${change} <id> not-relevant --reason "...".` : "The code has everything its target flows add, and nothing they don't name.");
+    return bad ? 1 : 0;
+  } catch (e) {
+    if (e instanceof ConformError) {
+      io.err(e.message);
+      return 2;
+    }
+    throw e;
+  }
+}
+export {
+  changeConformCommand
+};