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

package/dist/chunk-FVQISWPW.js

@@ -0,0 +1,296 @@
+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 {
+  table
+} from "./chunk-VOGCSYOI.js";
+import {
+  readCatalog
+} from "./chunk-OLWFG75W.js";
+import {
+  TriageError,
+  buildTriage,
+  classify,
+  scanInputs
+} from "./chunk-23W7VWKR.js";
+import {
+  readDrawio,
+  reconcile
+} from "./chunk-7EKXJZ2Y.js";
+import {
+  inputsDirOf,
+  loadOrgPack,
+  orgPackDirOf,
+  recordPath,
+  serializeRecord
+} from "./chunk-S2A7YC3Q.js";
+
+// packages/cli/dist/intake-commands.js
+import { createHash } from "node:crypto";
+import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { userInfo } from "node:os";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
+var inboxRelOf = (root) => relative(root, join(inputsDirOf(root), "inbox")).split(sep).join("/");
+async function filesUnder(dir) {
+  const out = [];
+  async function walk(d) {
+    let entries;
+    try {
+      entries = await readdir(d, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries.sort((a, b) => a.name < b.name ? -1 : 1)) {
+      const full = join(d, e.name);
+      if (e.isDirectory())
+        await walk(full);
+      else if (e.isFile())
+        out.push(full);
+    }
+  }
+  await walk(dir);
+  return out;
+}
+var sha256 = (b) => createHash("sha256").update(b).digest("hex");
+var rel = (root, p) => relative(root, p).split(sep).join("/");
+async function addToInbox(root, files) {
+  const INBOX = inboxRelOf(root);
+  const inbox = join(root, ...INBOX.split("/"));
+  const known = /* @__PURE__ */ new Map();
+  for (const f of await filesUnder(inputsDirOf(root)))
+    known.set(sha256(new Uint8Array(await readFile(f))), rel(root, f));
+  const added = [];
+  const refused = [];
+  for (const { name, bytes } of files) {
+    if (!name || /[\\/]/.test(name) || name === "." || name === "..") {
+      refused.push({ name, why: "give a file name without a folder in it" });
+      continue;
+    }
+    if (bytes.length === 0) {
+      refused.push({ name, why: "it is empty" });
+      continue;
+    }
+    const hash = sha256(bytes);
+    const already = known.get(hash);
+    if (already) {
+      refused.push({ name, why: `it is already in inputs as ${already}` });
+      continue;
+    }
+    const dot = name.lastIndexOf(".");
+    const [stem, ext] = dot > 0 ? [name.slice(0, dot), name.slice(dot)] : [name, ""];
+    await mkdir(inbox, { recursive: true });
+    const taken = new Set(await readdir(inbox));
+    let target = name;
+    for (let n = 2; taken.has(target); n++)
+      target = `${stem}-${n}${ext}`;
+    await writeFile(join(inbox, target), bytes);
+    const path = `${INBOX}/${target}`;
+    known.set(hash, path);
+    added.push({ name, path, kind: classify(target, bytes).classification });
+  }
+  return { added, refused };
+}
+async function intakeAdd(root, files, io) {
+  if (files.length === 0) {
+    io.err("Name at least one file to add.");
+    return 2;
+  }
+  let problems = false;
+  let added = 0;
+  let documents = 0;
+  const ALREADY = "it is already in inputs as ";
+  for (const f of files) {
+    const src = resolve(f);
+    let bytes;
+    try {
+      bytes = new Uint8Array(await readFile(src));
+    } catch {
+      io.err(`Can't read ${f}.`);
+      problems = true;
+      continue;
+    }
+    const r = await addToInbox(root, [{ name: basename(src), bytes }]);
+    for (const x of r.refused) {
+      io.err(x.why.startsWith(ALREADY) ? `${f} is already in inputs as ${x.why.slice(ALREADY.length)}; not copied.` : `${f} wasn't copied: ${x.why}.`);
+      problems = true;
+    }
+    for (const a of r.added) {
+      const reading = a.kind === "document" || a.kind === "image" ? ", needs reading" : "";
+      io.out(`Added ${a.path} (${a.kind}${reading}).`);
+      added++;
+      if (a.kind === "document")
+        documents++;
+    }
+  }
+  if (added > 0)
+    io.out("Run atticus intake list to see what Atticus made of them.");
+  if (documents > 0)
+    io.out("To read the documents into knowledge every change can use: atticus sources sync --source inputs, then atticus knowledge scan --source inputs.");
+  return problems ? 1 : 0;
+}
+async function intakeContext(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 inputs = await scanInputs({
+    root,
+    orgPack: op,
+    records: [...generated.records, ...curated.records],
+    inputsDir: inputsDirOf(root)
+  });
+  return { op, records: generated.records, curated: curated.records, inputs };
+}
+var STATUS_WORDS = [
+  ["read", (n) => `${n} read`],
+  ["needs-reading", (n) => `${n} need${n === 1 ? "s" : ""} reading`],
+  ["no-reader", (n) => `${n} with no reader yet`],
+  ["unresolved", (n) => `${n} waiting for a system name`],
+  ["duplicate", (n) => `${n} duplicate${n === 1 ? "" : "s"}`],
+  ["superseded", (n) => `${n} older version${n === 1 ? "" : "s"}`],
+  ["failed", (n) => `${n} failed`]
+];
+function chains(docs) {
+  const byId = new Map(docs.filter((d) => d.id).map((d) => [d.id, d]));
+  const replaced = new Set(docs.flatMap((d) => d.supersededBy ? [d.supersededBy] : []));
+  const out = [];
+  for (const d of docs) {
+    if (!d.supersededBy || d.id && replaced.has(d.id))
+      continue;
+    const chain = [d.path];
+    const seen = /* @__PURE__ */ new Set([d.id]);
+    for (let next = byId.get(d.supersededBy); next && !seen.has(next.id); ) {
+      chain.push(next.path);
+      seen.add(next.id);
+      next = next.supersededBy ? byId.get(next.supersededBy) : void 0;
+    }
+    out.push(chain);
+  }
+  return out;
+}
+async function intakeList(root, io, o) {
+  const { inputs } = await intakeContext(root, io);
+  const { documents, problems } = inputs;
+  if (o.json) {
+    io.out(JSON.stringify({ documents, chains: chains(documents), problems }, null, 2));
+    return problems.length > 0 ? 1 : 0;
+  }
+  if (documents.length === 0) {
+    io.out("Nothing in inputs/ yet: drop files into inputs/inbox/, or run atticus intake add <files>.");
+    return problems.length > 0 ? 1 : 0;
+  }
+  for (const l of table(["PATH", "TYPE", "STATUS", "SYSTEMS"], documents.map((d) => [
+    d.path,
+    d.classification,
+    d.duplicateOf ? `duplicate of ${d.duplicateOf}` : d.status,
+    d.systems.join(", ")
+  ])))
+    io.out(l);
+  const ch = chains(documents);
+  if (ch.length > 0) {
+    io.out("Versions:");
+    for (const c of ch)
+      io.out(`  ${c.join(" \u2192 ")}`);
+  }
+  const counts = STATUS_WORDS.map(([s, words]) => {
+    const n = documents.filter((d) => d.status === s).length;
+    return n > 0 ? words(n) : "";
+  }).filter(Boolean);
+  io.out(`${documents.length} file${documents.length === 1 ? "" : "s"}: ${counts.join(", ")}.`);
+  for (const p of problems)
+    io.out(`  ! ${p.path}: ${p.message}`);
+  return problems.length > 0 ? 1 : 0;
+}
+async function triageOf(root, io) {
+  const { op, records, curated, inputs } = await intakeContext(root, io);
+  if (records.length === 0 && inputs.documents.length > 0)
+    io.err("The catalog is empty: run atticus scan first, or most diagram edges will look unknown.");
+  const profile = op.profiles.find((p) => p.profile)?.profile;
+  const all = [...records, ...curated];
+  const reconcileItems = [];
+  for (const d of inputs.documents.filter((x) => x.classification === "diagram" && x.status === "read" && x.reader?.startsWith("drawio@"))) {
+    const xml = await readFile(join(root, ...d.path.split("/")), "utf8");
+    reconcileItems.push({
+      file: d.path,
+      items: reconcile({
+        diagram: readDrawio(xml, profile?.legend),
+        file: d.path,
+        records: all,
+        systems: profile?.systems ?? [],
+        patterns: op.patterns
+      }).items
+    });
+  }
+  return buildTriage({ records, inputs, decisions: curated, reconcileItems, ai: op.runtime.ai });
+}
+async function triageList(root, io, o) {
+  const { items } = await triageOf(root, io);
+  if (o.json) {
+    io.out(JSON.stringify({ items }, null, 2));
+    return items.length > 0 ? 1 : 0;
+  }
+  if (items.length === 0) {
+    io.out("Nothing to triage.");
+    return 0;
+  }
+  io.out(`${items.length} item${items.length === 1 ? "" : "s"} to decide.`);
+  for (const i of items) {
+    io.out("");
+    io.out(`${i.id} (${i.kind})`);
+    io.out(`  ${i.summary}`);
+    const where = `${i.source.path}${i.source.line ? `:${i.source.line}` : ""}`;
+    io.out(`  at ${where}${i.source.cell ? ` (cell ${i.source.cell})` : ""}`);
+    i.options.forEach((opt, n) => io.out(`  ${n + 1}. ${opt.label}`));
+    if (i.next)
+      io.out(`  \u2192 ${i.next}`);
+  }
+  io.out("");
+  io.out("Decide one with: atticus triage decide <item> <option>");
+  return 1;
+}
+async function triageDecide(root, itemId, option, o, io) {
+  const t = await triageOf(root, io);
+  const item = t.items.find((i) => i.id === itemId);
+  if (!item) {
+    io.err(`There is no open triage item ${itemId}. List them with: atticus triage`);
+    return 1;
+  }
+  if (!Number.isInteger(option) || option < 1 || option > item.options.length) {
+    const n = item.options.length;
+    io.err(`${itemId} has ${n} option${n === 1 ? "" : "s"}; pick 1 to ${n}.`);
+    return 2;
+  }
+  let decision;
+  try {
+    decision = t.decide(itemId, option - 1, {
+      by: o.by ?? userInfo().username,
+      ...o.reason ? { reason: o.reason } : {}
+    });
+  } catch (e) {
+    if (e instanceof TriageError) {
+      io.err(e.message);
+      return 1;
+    }
+    throw e;
+  }
+  const op = await loadOrgPack(join(orgPackDirOf(root)));
+  const relPath = `${op.sources.layout.catalog}/curated/${recordPath(decision)}`;
+  const full = join(root, ...relPath.split("/"));
+  await mkdir(dirname(full), { recursive: true });
+  await writeFile(full, serializeRecord(decision), "utf8");
+  io.out(`Wrote ${relPath}: ${item.options[option - 1].label}. Commit it so everyone's triage uses it.`);
+  return 0;
+}
+
+export {
+  addToInbox,
+  intakeAdd,
+  intakeContext,
+  intakeList,
+  triageList,
+  triageDecide
+};

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
+};