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

package/dist/chunk-NX6QEEOA.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-6RGIM2ZH.js";
+import "./chunk-XZJE6WIT.js";
+import {
+  AssistantId,
+  external_exports,
+  loadOrgPack,
+  orgPackDirOf,
+  runsDirOf,
+  runsRelOf
+} from "./chunk-JMOLB347.js";
+import "./chunk-MMB2OHUY.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
+};

package/dist/chunk-O6ILVBYB.js

@@ -0,0 +1,18 @@
+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 {
+  AREAS,
+  commandCatalog,
+  parseHelp
+} from "./chunk-NBQO75XT.js";
+import "./chunk-BXBCMGIQ.js";
+import "./chunk-4Q3NN7VF.js";
+import "./chunk-TV45EUGM.js";
+export {
+  AREAS,
+  commandCatalog,
+  parseHelp
+};

package/dist/chunk-OFWYZH6B.js

@@ -0,0 +1,230 @@
+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 {
+  renderTaskContext,
+  taskContext
+} from "./chunk-EV4TEFOD.js";
+import "./chunk-6N2GUZMZ.js";
+import "./chunk-T6ESD5KM.js";
+import {
+  changeFolder,
+  changeStore
+} from "./chunk-3LU6YCSQ.js";
+import "./chunk-L7I5PKGD.js";
+import "./chunk-CAN3EBE5.js";
+import "./chunk-IILZ7J3L.js";
+import "./chunk-TEBBD4XH.js";
+import "./chunk-XPWSNKF3.js";
+import {
+  attachToChange
+} from "./chunk-WIMOJMAK.js";
+import "./chunk-5V5BJACL.js";
+import "./chunk-GVFUEGGM.js";
+import "./chunk-XNRPCI23.js";
+import "./chunk-XZJE6WIT.js";
+import "./chunk-FMRMTI7W.js";
+import "./chunk-BKFGGJKA.js";
+import {
+  changesRelOf,
+  inputsDirOf
+} from "./chunk-JMOLB347.js";
+import "./chunk-MMB2OHUY.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/attach-commands.js
+import { createHash } from "node:crypto";
+import { readdir, readFile } from "node:fs/promises";
+import { basename, join, relative, resolve, sep } from "node:path";
+var sha256 = (b) => createHash("sha256").update(b).digest("hex");
+async function filesUnder(dir) {
+  const out = [];
+  const walk = async (d) => {
+    for (const e of await readdir(d, { withFileTypes: true }).catch(() => []))
+      if (e.isDirectory())
+        await walk(join(d, e.name));
+      else if (e.isFile())
+        out.push(join(d, e.name));
+  };
+  await walk(dir);
+  return out;
+}
+async function metarepoInputs(root) {
+  const out = /* @__PURE__ */ new Map();
+  for (const f of await filesUnder(inputsDirOf(root)))
+    out.set(sha256(new Uint8Array(await readFile(f))), relative(root, f).split(sep).join("/"));
+  return out;
+}
+var AttachError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "AttachError";
+  }
+};
+async function attachFiles(root, change, files, by, now = /* @__PURE__ */ new Date(), replaces) {
+  const c = await changeStore(root).read(change).catch(() => {
+    throw new AttachError("not-found", `There is no change ${change}: atticus change list shows them.`);
+  });
+  const known = await metarepoInputs(root);
+  return attachToChange(changeFolder(root, c.id), files, {
+    by,
+    at: now.toISOString().replace(/\.\d{3}Z$/, "Z"),
+    elsewhere: (h) => known.get(h),
+    ...replaces ? { replaces } : {}
+  });
+}
+async function promoteChangeInput(root, change, file) {
+  const c = await changeStore(root).read(change).catch(() => {
+    throw new AttachError("not-found", `There is no change ${change}: atticus change list shows them.`);
+  });
+  const name = file.replace(/^inputs\//, "");
+  if (!name || /[\\/]/.test(name) || name === "." || name === "..")
+    throw new AttachError("invalid", `Name one attached file, such as inputs/${basename(file) || "rules.pdf"}.`);
+  let bytes;
+  try {
+    bytes = new Uint8Array(await readFile(join(changeFolder(root, c.id), "inputs", name)));
+  } catch {
+    throw new AttachError("not-found", `inputs/${name} isn't attached to ${c.id}: atticus change attach ${c.id} adds it.`);
+  }
+  const { addToInbox } = await import("./chunk-LEHZTKB3.js");
+  const r = await addToInbox(root, [{ name, bytes }]);
+  const added = r.added[0];
+  if (!added)
+    throw new AttachError("invalid", `inputs/${name}: ${r.refused[0]?.why ?? "refused"}`);
+  return {
+    path: added.path,
+    note: `Copied to ${added.path}: general knowledge, read at the next atticus sources sync. ${c.id} keeps its copy. Commit both through a pull request.`
+  };
+}
+function attachedLine(rel, a) {
+  const what = a.read === "text" ? `${a.kind}, ${a.format}; read, cited by ${a.citeBy}` : a.kind === "image" ? "a picture: your assistant looks at it in the chat; Atticus doesn't read pictures" : `${a.format}: no reader takes it, so the steps name it without its text`;
+  return `Attached ${rel}/${a.path} (${what})${a.supersedes ? `, a newer version of ${a.supersedes}` : ""}${a.defences ? `; the defences found ${a.defences.risk} risk` : ""}.`;
+}
+async function changeAttachCli(root, change, paths, o, io) {
+  if (change && o.prototype) {
+    if (paths.length) {
+      const { PROTOTYPE_CLI_WORDS } = await import("./chunk-EHUYLNLC.js");
+      io.err(PROTOTYPE_CLI_WORDS.usage(change, o.prototype));
+      return 2;
+    }
+    const { attachPrototype } = await import("./chunk-EHUYLNLC.js");
+    return attachPrototype(root, change, o.prototype, { by: o.by, ...o.json ? { json: true } : {}, ...o.now ? { now: o.now } : {} }, io);
+  }
+  if (change && o.like) {
+    if (paths.length) {
+      io.err("--like names an archived change, attached on its own: atticus change attach add-refund-window --like raise-transfer-limit");
+      return 2;
+    }
+    const { attachPastChange, findPastChange } = await import("./chunk-RIEFYHXI.js");
+    const folder = await findPastChange(root, o.like);
+    if (!folder) {
+      io.err(`There is no archived change ${o.like}: atticus change similar "<what it is about>" lists them.`);
+      return 1;
+    }
+    try {
+      const name = await attachPastChange(root, change, folder, o.by, o.now);
+      io.out(`Attached ${folder} as inputs/${name}: the change's steps read it as an example.`);
+      return 0;
+    } catch (e) {
+      if (e instanceof AttachError) {
+        io.err(e.message);
+        return 1;
+      }
+      throw e;
+    }
+  }
+  if (change && o.promote) {
+    if (paths.length) {
+      io.err("--promote names one file already attached; attach new files without it, for example: atticus change attach add-refund-window --promote inputs/refund-rules.pdf");
+      return 2;
+    }
+    try {
+      const r2 = await promoteChangeInput(root, change, o.promote);
+      if (o.json)
+        io.out(JSON.stringify(r2, null, 2));
+      else
+        io.out(r2.note);
+      return 0;
+    } catch (e) {
+      if (e instanceof AttachError) {
+        io.err(e.message);
+        return 1;
+      }
+      throw e;
+    }
+  }
+  if (!change || paths.length === 0) {
+    io.err("Usage: atticus change attach <change> <files...>, for example: atticus change attach add-refund-window refund-rules.pdf");
+    return 2;
+  }
+  if (o.replaces && paths.length !== 1) {
+    io.err("--replaces names the one attached file that the file given replaces: attach one file with it, for example: atticus change attach add-refund-window refund-rules-v2.pdf --replaces inputs/refund-rules-v1.pdf");
+    return 2;
+  }
+  const files = [];
+  let problems = false;
+  for (const p of paths) {
+    try {
+      files.push({ name: basename(p), bytes: new Uint8Array(await readFile(resolve(p))) });
+    } catch {
+      io.err(`Can't read ${p}.`);
+      problems = true;
+    }
+  }
+  let r;
+  try {
+    r = await attachFiles(root, change, files, o.by, o.now, o.replaces);
+  } catch (e) {
+    if (e instanceof AttachError) {
+      io.err(e.message);
+      return 1;
+    }
+    throw e;
+  }
+  if (o.json) {
+    io.out(JSON.stringify(r, null, 2));
+    return r.refused.length || problems ? 1 : 0;
+  }
+  const rel = `${changesRelOf(root)}/${change}`;
+  for (const a of r.added)
+    io.out(attachedLine(rel, a));
+  for (const x of r.refused)
+    io.err(`${x.name}: not attached. ${x.why}`);
+  for (const n of r.notes)
+    io.out(n);
+  if (r.added.length)
+    io.out(`The change's steps read them as data, citing each by file and line or page: atticus next says which step is next. Commit ${rel}/inputs/ with the change.`);
+  return r.refused.length || problems ? 1 : 0;
+}
+async function taskContextCli(root, change, task, o, io) {
+  if (!change || !task) {
+    io.err("Usage: atticus task context <change> <task> [--json|--markdown], for example: atticus task context add-refund-window 1.2");
+    return 2;
+  }
+  try {
+    const command = `atticus task context ${change} ${task}`;
+    const c = await taskContext(root, change, task, {
+      ask: { command, rerun: command, at: (o.now ?? /* @__PURE__ */ new Date()).toISOString() }
+    });
+    io.out(o.json && !o.markdown ? JSON.stringify(c, null, 2) : renderTaskContext(c).trimEnd());
+    return 0;
+  } catch (e) {
+    if (e instanceof Error && ["PlannerError", "ChangeError", "ChangeFileError"].includes(e.name)) {
+      io.err(e.message);
+      return 1;
+    }
+    throw e;
+  }
+}
+export {
+  AttachError,
+  attachFiles,
+  attachedLine,
+  changeAttachCli,
+  promoteChangeInput,
+  taskContextCli
+};

package/dist/chunk-OHXTB6CO.js

@@ -0,0 +1,50 @@
+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 {
+  ReadPlanFile,
+  globHolds,
+  loadReadPlan,
+  mapSpent,
+  migrateReadPlan,
+  ownStarts,
+  partOfWords,
+  readCostOf,
+  readCostWords,
+  readPlanProgress,
+  readPlanRelOf,
+  recordReadProgress,
+  recordReported,
+  saveReadPlan,
+  tokensWords,
+  writeReadPlan
+} from "./chunk-LVBPY2M6.js";
+import "./chunk-ASKDCMW5.js";
+import "./chunk-LDIARP6F.js";
+import "./chunk-XPWSNKF3.js";
+import "./chunk-GVFUEGGM.js";
+import "./chunk-XZJE6WIT.js";
+import "./chunk-FMRMTI7W.js";
+import "./chunk-JMOLB347.js";
+import "./chunk-MMB2OHUY.js";
+import "./chunk-TV45EUGM.js";
+export {
+  ReadPlanFile,
+  globHolds,
+  loadReadPlan,
+  mapSpent,
+  migrateReadPlan,
+  ownStarts,
+  partOfWords,
+  readCostOf,
+  readCostWords,
+  readPlanProgress,
+  readPlanRelOf,
+  recordReadProgress,
+  recordReported,
+  saveReadPlan,
+  tokensWords,
+  writeReadPlan
+};

package/dist/chunk-OJN7WME4.js

@@ -0,0 +1,34 @@
+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 {
+  citesCli,
+  fileInRepo,
+  uiCiteRoutes
+} from "./chunk-TC3KTG33.js";
+import "./chunk-ZTNS3L5Z.js";
+import "./chunk-HR4DVO6X.js";
+import "./chunk-T6ESD5KM.js";
+import "./chunk-3LU6YCSQ.js";
+import "./chunk-L7I5PKGD.js";
+import "./chunk-CAN3EBE5.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-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 {
+  citesCli,
+  fileInRepo,
+  uiCiteRoutes
+};