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

package/dist/chunk-FITWGOJ2.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-27NKUS3X.js";
+import {
+  VIEW_NAMES,
+  ViewError,
+  buildView,
+  shapeLibrary,
+  toDrawio,
+  toMermaid,
+  viewFromDiagram
+} from "./chunk-PAMPPUR6.js";
+import {
+  readDrawio
+} from "./chunk-7EKXJZ2Y.js";
+import {
+  loadOrgPack,
+  orgPackDirOf
+} from "./chunk-S2A7YC3Q.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-FQXYPF7E.js

@@ -0,0 +1,147 @@
+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 {
+  readReviewed
+} from "./chunk-CR3MTH32.js";
+import {
+  citedFiles,
+  external_exports,
+  factsDirOf,
+  factsRelOf,
+  parseFacts,
+  require_dist
+} from "./chunk-S2A7YC3Q.js";
+import {
+  writeFileAtomic
+} from "./chunk-D3PO4DOZ.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/map-parts.js
+var import_yaml = __toESM(require_dist(), 1);
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+var Part = external_exports.strictObject({
+  part: external_exports.number().int().positive(),
+  paths: external_exports.array(external_exports.string().min(1)).min(1),
+  files: external_exports.number().int().nonnegative(),
+  tokens: external_exports.number().int().nonnegative()
+});
+var ReadPlanFile = external_exports.strictObject({
+  schemaVersion: external_exports.literal(1),
+  repo: external_exports.string().min(1),
+  /** The commit the plan was made at; the plan is stale at another commit. */
+  commit: external_exports.string().min(1),
+  /** The session token budget the parts were planned for. */
+  session: external_exports.number().int().positive(),
+  plannedAt: external_exports.string().min(1),
+  parts: external_exports.array(Part).min(1)
+});
+var readPlanRelOf = (root, repo) => `${factsRelOf(root)}/${repo}.read-plan.yaml`;
+var readPlanPath = (root, repo) => join(factsDirOf(root), `${repo}.read-plan.yaml`);
+function unitOf(glob) {
+  if (glob === "**")
+    return { glob, dir: "", deep: true };
+  if (glob.endsWith("/**"))
+    return { glob, dir: glob.slice(0, -3), deep: true };
+  if (glob === "*")
+    return { glob, dir: "", deep: false };
+  if (glob.endsWith("/*"))
+    return { glob, dir: glob.slice(0, -2), deep: false };
+  return { glob, dir: glob.replace(/\/?[^/]*$/, ""), deep: false };
+}
+function folderOf(path) {
+  const star = path.search(/[*?]/);
+  if (star < 0)
+    return { dir: path.replace(/\/?[^/]*$/, ""), deep: false };
+  return { dir: path.slice(0, star).replace(/\/$/, ""), deep: true };
+}
+var under = (dir, of) => of === "" || dir === of || dir.startsWith(`${of}/`);
+async function writeReadPlan(root, repo, o) {
+  const plan = {
+    schemaVersion: 1,
+    repo,
+    commit: o.commit,
+    session: o.session,
+    plannedAt: o.now ?? (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z"),
+    parts: o.parts.map((p, i) => ({
+      part: i + 1,
+      paths: [...p.paths],
+      files: p.files,
+      tokens: p.tokens
+    }))
+  };
+  await writeFileAtomic(readPlanPath(root, repo), `# The parts this repo is read in (ADR 0124 addendum A-ledger), as atticus map --estimate planned them.
+# Which part is next is read back from the facts; atticus next says it. Atticus writes this file.
+${(0, import_yaml.stringify)(plan, { lineWidth: 0 })}`);
+  return plan;
+}
+async function loadReadPlan(root, repo) {
+  const text = await readFile(readPlanPath(root, repo), "utf8").catch(() => void 0);
+  if (text === void 0)
+    return void 0;
+  try {
+    const r = ReadPlanFile.safeParse((0, import_yaml.parse)(text));
+    return r.success ? r.data : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function coveredPaths(root, repo) {
+  const out = /* @__PURE__ */ new Set();
+  const text = await readFile(join(factsDirOf(root), `${repo}.jsonl`), "utf8").catch(() => void 0);
+  if (text !== void 0) {
+    const parsed = parseFacts(text);
+    const facts = parsed.ok ? parsed.facts : [];
+    for (const f of facts)
+      for (const p of citedFiles(f))
+        out.add(p);
+  }
+  for (const e of (await readReviewed(root, repo)).entries)
+    out.add(e.path);
+  return [...out];
+}
+async function readPlanProgress(root, repo, o = {}) {
+  const plan = await loadReadPlan(root, repo);
+  if (!plan)
+    return void 0;
+  const covered = (await coveredPaths(root, repo)).map(folderOf);
+  const parts = plan.parts.map((p) => {
+    const units = p.paths.map(unitOf);
+    const hit = (u) => covered.some((c) => u.deep ? under(c.dir, u.dir) : c.dir === u.dir || c.deep && under(u.dir, c.dir));
+    const yes = units.filter(hit).map((u) => u.glob);
+    const no = units.filter((u) => !hit(u)).map((u) => u.glob);
+    return {
+      ...p,
+      state: no.length === 0 ? "done" : yes.length ? "in-progress" : "to-read",
+      covered: yes,
+      left: no
+    };
+  });
+  const done = parts.filter((p) => p.state === "done").length;
+  const next = parts.find((p) => p.state !== "done");
+  return {
+    repo,
+    commit: plan.commit,
+    session: plan.session,
+    plannedAt: plan.plannedAt,
+    parts,
+    total: parts.length,
+    done,
+    ...next ? { next } : {},
+    stale: o.commit !== void 0 && o.commit !== plan.commit
+  };
+}
+var partOfWords = (p) => `part ${p.part} of ${p.total}`;
+
+export {
+  readPlanRelOf,
+  writeReadPlan,
+  loadReadPlan,
+  readPlanProgress,
+  partOfWords
+};

package/dist/chunk-G2B4ZQGH.js

@@ -0,0 +1,240 @@
+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 {
+  api_exports,
+  changesDirOf,
+  orgPackDirOf,
+  require_dist
+} from "./chunk-S2A7YC3Q.js";
+import {
+  ensureLocalIgnore,
+  redactText
+} from "./chunk-D3PO4DOZ.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/history.js
+var import_yaml = __toESM(require_dist(), 1);
+import { randomBytes } from "node:crypto";
+import { existsSync } from "node:fs";
+import { appendFile, mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+var historyDirOf = (root) => join(root, ".atticus", "history");
+var ME = (root) => join(root, ".atticus", "me.yaml");
+var HISTORY_ID = /^h-\d{14}-[0-9a-f]{6}$/;
+function cutText(text, max = api_exports.HISTORY_TEXT_MAX_BYTES) {
+  const bytes = Buffer.from(text, "utf8");
+  if (bytes.length <= max)
+    return { text, size: bytes.length, truncated: false };
+  const cut = bytes.subarray(0, max).toString("utf8").replace(/�+$/, "");
+  return { text: cut, size: bytes.length, truncated: true };
+}
+function maskSecrets(text) {
+  const kept = [];
+  let long = false;
+  const shielded = text.replace(/[A-Za-z0-9+_-]{257,}={0,2}/g, (run) => {
+    if (/\d/.test(run) && /[A-Z]/.test(run) && /[a-z]/.test(run)) {
+      long = true;
+      return "***";
+    }
+    kept.push(run);
+    return `\uE000${kept.length - 1}\uE001`;
+  });
+  const red = redactText(shielded, { home: "", user: "" });
+  const out = red.replace(/(\d+)/g, (_, i) => kept[Number(i)]);
+  return { text: out, masked: long || red !== shielded };
+}
+async function changeIds(root) {
+  const dir = changesDirOf(root);
+  const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+  return entries.filter((e) => e.isDirectory() && e.name !== "archive" && existsSync(join(dir, e.name, "change.yaml"))).map((e) => e.name).sort();
+}
+async function branchChange(root) {
+  let git = join(root, ".git");
+  const asFile = await readFile(git, "utf8").catch(() => void 0);
+  const m = asFile !== void 0 ? /^gitdir:\s*(.+)$/m.exec(asFile) : null;
+  if (m)
+    git = resolve(root, m[1].trim());
+  const head = await readFile(join(git, "HEAD"), "utf8").catch(() => "");
+  const b = /^ref: refs\/heads\/change\/([a-z0-9][a-z0-9-]*)\s*$/m.exec(head);
+  return b?.[1];
+}
+async function recordingOf(root) {
+  const said = async (file) => {
+    const text = await readFile(file, "utf8").catch(() => void 0);
+    if (!text)
+      return void 0;
+    try {
+      const y = (0, import_yaml.parse)(text);
+      return y?.history?.record;
+    } catch {
+      return void 0;
+    }
+  };
+  if (await said(join(orgPackDirOf(root), "runtime.yaml")) === false)
+    return { on: false, offBy: "org-pack" };
+  if (await said(ME(root)) === false)
+    return { on: false, offBy: "local" };
+  return { on: true };
+}
+async function setLocalRecording(root, on) {
+  const file = ME(root);
+  const text = await readFile(file, "utf8").catch(() => "");
+  let doc = (0, import_yaml.parseDocument)(text);
+  if (!(0, import_yaml.isMap)(doc.contents))
+    doc = new import_yaml.Document({});
+  doc.setIn(["history", "record"], on);
+  await mkdir(dirname(file), { recursive: true });
+  await writeFile(file, doc.toString(), "utf8");
+  await ensureLocalIgnore(root);
+}
+var pad = (n, w = 2) => String(n).padStart(w, "0");
+var stamp = (d) => `${d.getUTCFullYear()}${pad(d.getUTCMonth() + 1)}${pad(d.getUTCDate())}${pad(d.getUTCHours())}${pad(d.getUTCMinutes())}${pad(d.getUTCSeconds())}`;
+async function addHistory(root, i) {
+  const recording = await recordingOf(root);
+  if (!recording.on)
+    return { off: recording };
+  const now = i.now ?? /* @__PURE__ */ new Date();
+  const masked = maskSecrets(i.text);
+  const original = Buffer.byteLength(i.text, "utf8");
+  const cut = cutText(masked.text);
+  const given = i.change?.trim();
+  const change = (given && (await changeIds(root)).includes(given) ? given : void 0) ?? await branchChange(root);
+  const command = i.command?.trim() || (i.kind === "prompt" ? /^\s*(\/[a-z][a-z0-9-]*)(?=\s|$)/.exec(i.text)?.[1] : void 0);
+  const record = {
+    id: `h-${stamp(now)}-${i.random ? i.random() : randomBytes(3).toString("hex")}`,
+    at: now.toISOString(),
+    surface: i.surface,
+    session: i.session?.trim() || `${i.surface}-${stamp(now).slice(0, 8)}`,
+    kind: i.kind,
+    text: cut.text,
+    size: original,
+    ...cut.truncated ? { truncated: true } : {},
+    ...masked.masked ? { masked: true } : {},
+    ...change ? { change } : {},
+    ...command ? { command } : {}
+  };
+  const dir = historyDirOf(root);
+  const file = join(dir, `${record.at.slice(0, 7)}.jsonl`);
+  if (record.kind === "response") {
+    const last = (await readLines(file)).filter((r) => r.session === record.session && r.surface === record.surface);
+    const prev = last.at(-1);
+    if (prev?.kind === "response" && prev.text === record.text)
+      return { record: prev };
+  }
+  await mkdir(dir, { recursive: true });
+  await ensureLocalIgnore(root);
+  await appendFile(file, JSON.stringify(record) + "\n", "utf8");
+  return { record };
+}
+async function readLines(file) {
+  const text = await readFile(file, "utf8").catch(() => "");
+  const out = [];
+  for (const line of text.split(/\r?\n/)) {
+    if (!line.trim())
+      continue;
+    let v;
+    try {
+      v = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const r = api_exports.HistoryRecord.safeParse(v);
+    if (r.success)
+      out.push(r.data);
+  }
+  return out;
+}
+async function readHistory(root) {
+  const dir = historyDirOf(root);
+  const files = (await readdir(dir).catch(() => [])).filter((f) => /^\d{4}-\d{2}\.jsonl$/.test(f)).sort();
+  const out = [];
+  for (const f of files)
+    out.push(...await readLines(join(dir, f)));
+  return out.sort((a, b) => a.at === b.at ? a.id.localeCompare(b.id) : a.at < b.at ? -1 : 1);
+}
+function pairTurns(records) {
+  const sorted = [...records].sort((a, b) => a.at === b.at ? a.id.localeCompare(b.id) : a.at < b.at ? -1 : 1);
+  const open = /* @__PURE__ */ new Map();
+  const turns = [];
+  for (const r of sorted) {
+    const key = `${r.surface}\0${r.session}`;
+    if (r.kind === "prompt") {
+      const t2 = {
+        session: r.session,
+        surface: r.surface,
+        at: r.at,
+        ...r.change ? { change: r.change } : {},
+        prompt: r
+      };
+      turns.push(t2);
+      open.set(key, t2);
+      continue;
+    }
+    const t = open.get(key);
+    if (t && !t.response) {
+      t.response = r;
+      if (!t.change && r.change)
+        t.change = r.change;
+      open.delete(key);
+    } else
+      turns.push({
+        session: r.session,
+        surface: r.surface,
+        at: r.at,
+        ...r.change ? { change: r.change } : {},
+        response: r
+      });
+  }
+  return turns.reverse();
+}
+function filterTurns(turns, o) {
+  const words = (o.filter ?? "").toLowerCase().split(/\s+/).filter(Boolean);
+  return turns.filter((t) => {
+    if (o.change && t.change !== o.change)
+      return false;
+    if (o.session && t.session !== o.session)
+      return false;
+    if (!words.length)
+      return true;
+    const hay = [
+      t.prompt?.text,
+      t.response?.text,
+      t.prompt?.command,
+      t.change,
+      t.session,
+      t.surface
+    ].filter(Boolean).join("\n").toLowerCase();
+    return words.every((w) => hay.includes(w));
+  });
+}
+async function listHistory(root, o = {}) {
+  const matched = filterTurns(pairTurns(await readHistory(root)), o);
+  return {
+    turns: o.limit ? matched.slice(0, o.limit) : matched,
+    total: matched.length,
+    recording: await recordingOf(root)
+  };
+}
+async function historyEntry(root, id) {
+  if (!HISTORY_ID.test(id))
+    return void 0;
+  const records = await readHistory(root);
+  const record = records.find((r) => r.id === id);
+  if (!record)
+    return void 0;
+  const turn = pairTurns(records).find((t) => t.prompt?.id === id || t.response?.id === id);
+  const pair = record.kind === "prompt" ? turn?.response : turn?.prompt;
+  return { record, ...pair ? { pair } : {} };
+}
+
+export {
+  setLocalRecording,
+  addHistory,
+  listHistory,
+  historyEntry
+};

package/dist/chunk-GBRFVT63.js

@@ -0,0 +1,45 @@
+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 {
+  BASELINE_FILE,
+  baselineCommand,
+  readBaseline,
+  setupCommand,
+  setupSteps
+} from "./chunk-YY6ZQQBP.js";
+import "./chunk-B2WLAWNJ.js";
+import "./chunk-AIOQPLA5.js";
+import "./chunk-3G4YI4ZU.js";
+import "./chunk-YISXLPHN.js";
+import "./chunk-GDLULHTC.js";
+import "./chunk-IPKHE5D6.js";
+import "./chunk-CKSITVS4.js";
+import "./chunk-L6SGQIR3.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-T6AIP7H5.js";
+import "./chunk-RZPYKDWS.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 {
+  BASELINE_FILE,
+  baselineCommand,
+  readBaseline,
+  setupCommand,
+  setupSteps
+};