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

package/dist/chunk-OSGQW2Z6.js

@@ -0,0 +1,104 @@
+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 {
+  acceptStandardChecks,
+  draftStandardChecks,
+  estimateScan
+} from "./chunk-6JLPXDWN.js";
+import "./chunk-R4TBNKKC.js";
+import "./chunk-NIXVDQVO.js";
+import "./chunk-UR7RMZ3R.js";
+import "./chunk-MKRBG5EF.js";
+import "./chunk-5XDNUJ4P.js";
+import {
+  loadOrgPack,
+  orgPackDirOf
+} from "./chunk-577AJVRS.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/wikis-commands.js
+var plural = (n, w) => `${n.toLocaleString("en")} ${w}${n === 1 ? "" : "s"}`;
+var str = (v) => typeof v === "string" && v.trim() ? v.trim() : void 0;
+async function sourcesEstimate(root, o, io) {
+  const op = await loadOrgPack(orgPackDirOf(root));
+  if (o.source && !op.sources.wikis.some((w) => w.id === o.source)) {
+    io.err(`There is no source ${o.source} in org-pack/sources.yaml.`);
+    return 2;
+  }
+  const pack = o.source ? {
+    ...op,
+    sources: { ...op.sources, wikis: op.sources.wikis.filter((w) => w.id === o.source) }
+  } : op;
+  const e = await estimateScan(root, {
+    orgPack: pack,
+    ...o.batchTokens ? { batchTokens: o.batchTokens } : {},
+    ...o.full ? { full: true } : {}
+  });
+  if (o.json) {
+    io.out(JSON.stringify(e, null, 2));
+    return e.sources.length ? 0 : 2;
+  }
+  if (!e.sources.length) {
+    io.err("There is no snapshot yet. Run atticus sources sync first: the estimate reads the snapshots.");
+    return 2;
+  }
+  io.out(`A knowledge scan would read ${plural(e.total.toRead, "page")} of ${plural(e.total.pages, "page")}, about ${plural(e.total.tokens, "token")}, in ${plural(e.total.calls, "model call")} (each call up to ${plural(e.room, "token")} of pages):`);
+  for (const s of e.sources)
+    io.out(`  ${s.source}: ${plural(s.toRead, "page")} to read of ${s.pages}${s.unchanged ? ` (${s.unchanged} as at the last scan)` : ""}, about ${plural(s.tokens, "token")}, ${plural(s.calls, "call")} on its own${s.capped ? `; ${s.capped} wait for a later run (maxPages ${s.cap})` : ""}`);
+  for (const id of e.notSynced)
+    io.out(`  ${id}: not synced yet (atticus sources sync --source ${id})`);
+  io.out("Each call is one prompt to the configured model (with Copilot, one premium request). Cap a source with maxPages in sources.yaml; atticus knowledge scan reads the rest on a later run.");
+  return 0;
+}
+async function standardsCli(root, command, values, io) {
+  const json = values.json === true;
+  try {
+    if (command === "propose") {
+      const d = await draftStandardChecks(root);
+      if (json) {
+        io.out(JSON.stringify(d, null, 2));
+        return 0;
+      }
+      if (!d.proposals.length)
+        io.out("No rule of a confirmed standard waits to be accepted.");
+      else {
+        io.out(`${plural(d.proposals.length, "critic check")} proposed from confirmed standards (nothing is enforced until accepted):`);
+        for (const p of d.proposals)
+          io.out(`  ${p.rule.id} (${p.rule.severity}): ${p.rule.title} [${p.page}, confirmed by ${p.verifiedBy}]`);
+      }
+      for (const l of d.left)
+        io.out(`  not proposed: ${l.item}: ${l.why}`);
+      io.out(`Written to ${d.file} and ${d.file.replace(/\.yaml$/, ".md")}. Accept them with atticus standards accept [--only id,id].`);
+      return 0;
+    }
+    if (command === "accept") {
+      const only = str(values.only)?.split(",").map((x) => x.trim()).filter(Boolean);
+      const r = await acceptStandardChecks(root, {
+        ...only ? { only } : {},
+        ...values["dry-run"] === true ? { dryRun: true } : {}
+      });
+      if (json) {
+        io.out(JSON.stringify(r, null, 2));
+        return 0;
+      }
+      const would = values["dry-run"] === true;
+      io.out(`${would ? "Would add" : "Added"} ${r.added.length ? r.added.join(", ") : "no check"} to ${r.file}; ${r.left} left proposed.`);
+      if (!would && r.added.length)
+        io.out("Commit the checklist through a pull request: merging it is the approval, and the critic runs it from then on.");
+      return 0;
+    }
+    io.err("Usage: atticus standards propose | atticus standards accept [--only id,id] [--dry-run]");
+    return 2;
+  } catch (e) {
+    io.err(e.message);
+    return 2;
+  }
+}
+export {
+  sourcesEstimate,
+  standardsCli
+};

package/dist/chunk-P3TKKBAH.js

@@ -0,0 +1,131 @@
+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 {
+  readCatalog
+} from "./chunk-AY2IUF4K.js";
+import {
+  VIEW_NAMES,
+  ViewError,
+  buildView,
+  shapeLibrary,
+  toDrawio,
+  toMermaid,
+  viewFromDiagram
+} from "./chunk-4GZXS6S2.js";
+import {
+  readDrawio
+} from "./chunk-NIXVDQVO.js";
+import {
+  loadOrgPack,
+  orgPackDirOf
+} from "./chunk-577AJVRS.js";
+
+// packages/cli/dist/diagram-commands.js
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join, relative, resolve, sep } from "node:path";
+async function loadCatalog(root, io) {
+  const op = await loadOrgPack(join(orgPackDirOf(root)));
+  const catalogDir = join(root, op.sources.layout.catalog);
+  const generated = await readCatalog(join(catalogDir, "generated"), { cacheRoot: root });
+  const curated = await readCatalog(join(catalogDir, "curated"), { cacheRoot: root });
+  for (const p of [...generated.problems, ...curated.problems])
+    io.err(`catalog ${p.file}: ${p.message}`);
+  const legend = op.profiles[0]?.profile?.legend;
+  return {
+    records: [...generated.records, ...curated.records],
+    generated: generated.records.length,
+    ...legend ? { legend } : {}
+  };
+}
+async function emit(root, text, out, io) {
+  if (!out) {
+    io.out(text.replace(/\n$/, ""));
+    return;
+  }
+  const full = resolve(root, out);
+  await mkdir(dirname(full), { recursive: true });
+  await writeFile(full, text, "utf8");
+  io.out(`Wrote ${relative(root, full).split(sep).join("/")}.`);
+}
+async function diagramRender(root, o, io) {
+  const format = o.format ?? "mermaid";
+  if (format !== "mermaid" && format !== "drawio" && format !== "json") {
+    io.err(`Unknown format "${format}": use mermaid, drawio or json.`);
+    return 2;
+  }
+  if (/\.drawio(\.xml)?$/i.test(o.view)) {
+    if (format !== "mermaid") {
+      io.err("A diagram file renders as Mermaid only.");
+      return 2;
+    }
+    const full = resolve(root, o.view);
+    let xml;
+    try {
+      xml = await readFile(full, "utf8");
+    } catch {
+      io.err(`Can't read ${o.view}`);
+      return 2;
+    }
+    const op = await loadOrgPack(join(orgPackDirOf(root)));
+    const diagram = readDrawio(xml, op.profiles[0]?.profile?.legend);
+    for (const p of diagram.problems)
+      io.err(`cell ${p.cell}: ${p.message}`);
+    const view2 = viewFromDiagram(diagram, relative(root, full).split(sep).join("/"));
+    await emit(root, toMermaid(view2), o.out, io);
+    return 0;
+  }
+  if (!VIEW_NAMES.includes(o.view)) {
+    io.err(`Unknown view "${o.view}": use ${VIEW_NAMES.join(", ")}, or name a .drawio file to show it as Mermaid.`);
+    return 2;
+  }
+  const name = o.view;
+  if ((name === "container" || name === "sequence") && !o.focus) {
+    io.err(name === "container" ? "A container view needs a system: --focus <system>." : "A sequence view needs record ids in order: --focus <id>,<id>,...");
+    return 2;
+  }
+  if (name === "sequence" && format !== "mermaid") {
+    io.err("A sequence view renders as Mermaid only.");
+    return 2;
+  }
+  const { records, generated } = await loadCatalog(root, io);
+  if (generated === 0) {
+    io.err("The catalog is empty: read the repos first (atticus map <repo>, then atticus verify <repo> --write).");
+    return 1;
+  }
+  let view;
+  try {
+    view = buildView(records, name, o.focus);
+  } catch (e) {
+    if (e instanceof ViewError) {
+      io.err(e.message);
+      return 1;
+    }
+    throw e;
+  }
+  if (view.type !== "sequence" && view.nodes.length === 0) {
+    io.err(`Nothing to draw: the catalog has nothing for the ${name} view${o.focus ? ` of ${o.focus}` : ""}.`);
+    return 1;
+  }
+  if (format === "json" && view.type !== "sequence") {
+    await emit(root, JSON.stringify(view), o.out, io);
+    return 0;
+  }
+  await emit(root, view.type !== "sequence" && format === "drawio" ? toDrawio(view) : toMermaid(view), o.out, io);
+  return 0;
+}
+async function diagramLibrary(out, io) {
+  const full = resolve(out);
+  await mkdir(dirname(full), { recursive: true });
+  await writeFile(full, shapeLibrary(), "utf8");
+  io.out(`Wrote ${out}. In draw.io, open it with File > Open Library from > Device.`);
+  return 0;
+}
+
+export {
+  loadCatalog,
+  diagramRender,
+  diagramLibrary
+};

package/dist/chunk-PEF5OEMB.js

@@ -0,0 +1,163 @@
+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 {
+  ASSISTANT_FORMATS,
+  assistantTier,
+  probeFileOf,
+  probeTier,
+  writeProbe
+} from "./chunk-LK44ULGI.js";
+import "./chunk-PGKHJYOB.js";
+import {
+  AssistantId,
+  external_exports,
+  loadOrgPack,
+  orgPackDirOf,
+  runsDirOf,
+  runsRelOf
+} from "./chunk-577AJVRS.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/probe-commands.js
+import { randomBytes } from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+var OPEN_HOURS = 24;
+var Challenge = external_exports.strictObject({
+  schemaVersion: external_exports.literal(1),
+  assistant: AssistantId,
+  code: external_exports.string().regex(/^[0-9a-f]{8}$/),
+  started: external_exports.iso.datetime(),
+  maxTokens: external_exports.number().int().min(1e3).optional()
+});
+var probeDir = (root) => join(runsDirOf(root), "probe");
+var probeRel = (root) => `${runsRelOf(root)}/probe`;
+function startIn(id) {
+  const f = ASSISTANT_FORMATS[id];
+  return id === "agents-md" ? `In ${f.typeIn}, ask it to follow ${f.commandPath("atticus-probe")}.` : `In ${f.typeIn}, run /atticus-probe.`;
+}
+async function probeCommand(root, o, io, deps = {}) {
+  const rt = (await loadOrgPack(orgPackDirOf(root))).runtime;
+  if (rt.ai === "off") {
+    io.err("AI is off here (runtime.yaml): there is no assistant to probe.");
+    return 1;
+  }
+  const want = o.assistant ?? rt.assistants.default;
+  const id = AssistantId.safeParse(want);
+  if (!id.success || !rt.assistants.allowed.includes(id.data)) {
+    io.err(`runtime.yaml doesn't allow ${want} here: it allows ${rt.assistants.allowed.join(", ")}.`);
+    return 2;
+  }
+  const assistant = id.data;
+  const now = (deps.now ?? (() => /* @__PURE__ */ new Date()))();
+  const challenge = {
+    schemaVersion: 1,
+    assistant,
+    code: deps.code?.() ?? randomBytes(4).toString("hex"),
+    started: now.toISOString(),
+    ...o.maxTokens !== void 0 ? { maxTokens: o.maxTokens } : {}
+  };
+  const dir = probeDir(root);
+  await rm(dir, { recursive: true, force: true });
+  await mkdir(dir, { recursive: true });
+  await writeFile(join(dir, "probe.json"), `${JSON.stringify(challenge, null, 2)}
+`, "utf8");
+  await writeFile(join(dir, "challenge.md"), [
+    "# Atticus capability probe",
+    "",
+    `Code: ${challenge.code}`,
+    "",
+    `Atticus wrote this file at ${challenge.started} for /atticus-probe. The steps of /atticus-probe say what to do with the code.`,
+    ""
+  ].join("\n"), "utf8");
+  const rel = probeRel(root);
+  const name = ASSISTANT_FORMATS[assistant].name;
+  const result = probeFileOf(assistant);
+  if (o.json) {
+    io.out(JSON.stringify({
+      assistant,
+      challenge: `${rel}/challenge.md`,
+      answerFile: `${rel}/answer.txt`,
+      result,
+      started: challenge.started,
+      expires: new Date(now.getTime() + OPEN_HOURS * 36e5).toISOString(),
+      ...o.maxTokens !== void 0 ? { maxTokens: o.maxTokens } : {}
+    }, null, 2));
+    return 0;
+  }
+  io.out(`Probing ${name} (another assistant runtime.yaml allows: --assistant <id>).`);
+  io.out(`${startIn(assistant)} It asks the assistant to open ${rel}/challenge.md, write the code it holds to ${rel}/answer.txt, and run atticus probe answer <code> itself.`);
+  io.out("An assistant that can't run commands gives you a line to paste in this terminal instead: atticus probe answer <code> --pasted.");
+  io.out("A chat with no /atticus-probe (a web chat) can't open files here: run atticus probe answer none --pasted.");
+  if (o.maxTokens === void 0)
+    io.out("Give your model's limit, the most tokens it takes in one prompt, with --max-tokens <n> on the answer if you know it: Atticus never guesses it.");
+  else
+    io.out(`Model limit: ${o.maxTokens} tokens, as you stated it.`);
+  io.out(`The probe is open for ${OPEN_HOURS} hours. Nothing leaves this machine: the answer is checked here and kept in ${result}.`);
+  return 0;
+}
+var yesNo = (b) => b ? "yes" : "no";
+async function probeAnswerCommand(root, given, o, io, deps = {}) {
+  if (!given) {
+    io.err("Usage: atticus probe answer <code|none> [--pasted] [--max-tokens n] [--json]");
+    return 2;
+  }
+  const dir = probeDir(root);
+  const rel = probeRel(root);
+  const parsed = Challenge.safeParse(await readFile(join(dir, "probe.json"), "utf8").then((t2) => JSON.parse(t2)).catch(() => void 0));
+  if (!parsed.success) {
+    io.err("No probe is under way here: start one with atticus probe.");
+    return 1;
+  }
+  const c = parsed.data;
+  const now = (deps.now ?? (() => /* @__PURE__ */ new Date()))();
+  if (now.getTime() - Date.parse(c.started) > OPEN_HOURS * 36e5) {
+    io.err(`The probe started at ${c.started} is more than ${OPEN_HOURS} hours old: start a new one with atticus probe.`);
+    return 1;
+  }
+  const code = given.trim().toLowerCase();
+  if (code !== "none" && code !== c.code) {
+    io.err(`${given.trim()} isn't the code in ${rel}/challenge.md: the assistant didn't read that file. Nothing was recorded. Run /atticus-probe again, or answer none if the assistant can't open files.`);
+    return 1;
+  }
+  const answerFile = join(dir, "answer.txt");
+  const written = existsSync(answerFile) ? (await readFile(answerFile, "utf8").catch(() => "")).trim().toLowerCase() : void 0;
+  const read = code === c.code;
+  const write = written === c.code;
+  const run = o.pasted !== true;
+  const maxTokens = o.maxTokens ?? c.maxTokens;
+  const result = {
+    schemaVersion: 1,
+    assistant: c.assistant,
+    measured: now.toISOString(),
+    tier: probeTier({ read, write, run }),
+    read,
+    write,
+    run,
+    answered: run ? "command" : "pasted",
+    ...maxTokens !== void 0 ? { maxTokens } : {}
+  };
+  const file = await writeProbe(root, result);
+  await rm(dir, { recursive: true, force: true });
+  const rt = (await loadOrgPack(orgPackDirOf(root))).runtime;
+  const t = assistantTier({ ...rt, assistants: { allowed: [c.assistant], default: c.assistant } }, { probes: [result], now });
+  if (o.json) {
+    io.out(JSON.stringify({ ...result, file, how: t.how }, null, 2));
+    return 0;
+  }
+  const name = ASSISTANT_FORMATS[c.assistant].name;
+  io.out(`Measured ${name}: opened the file Atticus wrote: ${yesNo(read)}; wrote a file: ${write ? "yes" : written === void 0 ? "no" : `no (${rel}/answer.txt doesn't hold the code)`}; ran a command itself: ${run ? "yes" : "no (the line was pasted)"}. That is ${result.tier === 1 ? "agentic (tier 1)" : result.tier === 2 ? "batched hand-off (tier 2)" : "copy-paste (tier 3)"}.`);
+  io.out(`The first read of a repo: ${t.how}`);
+  io.out(maxTokens !== void 0 ? `Model limit: ${maxTokens} tokens, as stated.` : "No model limit was stated: atticus probe --max-tokens <n> measures again with it, or give --max-tokens <n> on each atticus map.");
+  io.out(`Kept in ${file}, on this machine only (never committed). atticus doctor, init, adopt and map --estimate say this tier from now on.`);
+  return 0;
+}
+export {
+  probeAnswerCommand,
+  probeCommand
+};