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

package/dist/chunk-MH5OCRUM.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-577AJVRS.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-MKFYQQ5Q.js

@@ -0,0 +1,36 @@
+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));
+
+// packages/cli/dist/repo-ids.js
+function repoIdKey(id) {
+  return id.toLowerCase().replace(/_/g, "-").replace(/(?:[-.]v?\d+)+$/, "").replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "");
+}
+function cloneUrlKey(url) {
+  const u = url.trim();
+  if (!u || u === "." || u.startsWith("./") || u.startsWith("../"))
+    return void 0;
+  return u.replace(/[/\\]+$/, "").replace(/\.git$/i, "").replace(/^[a-z][a-z0-9+.-]*:\/\//i, "").replace(/^[^@/]+@/, "").replace(/^([^/:]+):(?!\d+\/)/, "$1/").toLowerCase();
+}
+var SAME_ID_WHY = "its id is the same once case, '_' and '-', and a version suffix are set aside";
+function nearRepos(entry, listed) {
+  const key = repoIdKey(entry.id);
+  const url = entry.url ? cloneUrlKey(entry.url) : void 0;
+  const out = [];
+  for (const r of listed) {
+    if (r.id === entry.id)
+      continue;
+    if (url && r.url && cloneUrlKey(r.url) === url)
+      out.push({ id: r.id, why: "it has the same clone URL" });
+    else if (key && repoIdKey(r.id) === key)
+      out.push({ id: r.id, why: SAME_ID_WHY });
+  }
+  return out;
+}
+
+export {
+  repoIdKey,
+  nearRepos
+};