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

package/dist/chunk-B2VSVN4P.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-YVLMBAYE.js";
+import "./chunk-HHUFVJF7.js";
+import "./chunk-DPHCFZ7W.js";
+import "./chunk-47QE246J.js";
+import "./chunk-XQ3YIV5R.js";
+import "./chunk-MGVYVW7Q.js";
+import "./chunk-NGPU2ARF.js";
+import "./chunk-AY2IUF4K.js";
+import "./chunk-6JLPXDWN.js";
+import "./chunk-4GZXS6S2.js";
+import "./chunk-R4TBNKKC.js";
+import "./chunk-NIXVDQVO.js";
+import "./chunk-UR7RMZ3R.js";
+import "./chunk-N4QZJJVB.js";
+import "./chunk-PGKHJYOB.js";
+import "./chunk-MKRBG5EF.js";
+import "./chunk-5XDNUJ4P.js";
+import "./chunk-577AJVRS.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+export {
+  citesCli,
+  fileInRepo,
+  uiCiteRoutes
+};

package/dist/chunk-B3O52AUQ.js

@@ -0,0 +1,275 @@
+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 {
+  repoFor
+} from "./chunk-XKS6THI5.js";
+import {
+  frameworkFacts,
+  insideRepo,
+  parseReviewed
+} from "./chunk-4GZXS6S2.js";
+import {
+  changesSince,
+  createGit
+} from "./chunk-PGKHJYOB.js";
+import {
+  Conventions,
+  DEFAULT_CONVENTIONS,
+  QuestionDraft,
+  factsDirOf,
+  isAdopted,
+  isSecretPath,
+  loadOrgPack,
+  orgPackDirOf,
+  parseCorrections,
+  parseFactsLines,
+  raiseQuestions,
+  require_dist,
+  serializeFacts
+} from "./chunk-577AJVRS.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/facts-files.js
+var import_yaml = __toESM(require_dist(), 1);
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+async function checkoutOf(root, repo, dir) {
+  return dir ?? (isAdopted(root) ? root : (await repoFor(root, repo))?.dir ?? void 0);
+}
+async function headOf(dir) {
+  try {
+    const r = await createGit({ timeoutMs: 3e4 })(["rev-parse", "HEAD"], dir);
+    return r.stdout.trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function carryOf(dir, facts, commit, git) {
+  if (!commit)
+    return { carry: {}, missing: [] };
+  const r = await changesSince(dir, facts.map((f) => f.commit), commit, git);
+  return { carry: r.changes, missing: r.missing };
+}
+async function conventionsAt(root) {
+  const file = join(orgPackDirOf(root), "conventions.yaml");
+  if (!existsSync(file))
+    return DEFAULT_CONVENTIONS;
+  try {
+    const r = Conventions.safeParse((0, import_yaml.parse)(await readFile(file, "utf8")));
+    return r.success ? r.data : DEFAULT_CONVENTIONS;
+  } catch {
+    return DEFAULT_CONVENTIONS;
+  }
+}
+async function excludesOf(root, repo) {
+  const file = join(orgPackDirOf(root), "scan", `${repo}.yaml`);
+  if (!existsSync(file))
+    return [];
+  try {
+    const doc = (0, import_yaml.parse)(await readFile(file, "utf8"));
+    return (doc?.exclude ?? []).map((e) => e.path).filter((p) => !!p);
+  } catch {
+    return [];
+  }
+}
+async function raiseReadQuestions(root, repo, lines, source, by) {
+  const drafts = [];
+  const problems = [];
+  for (const raw of lines) {
+    const line = JSON.stringify(raw);
+    const r2 = QuestionDraft.safeParse(raw);
+    if (!r2.success) {
+      problems.push({
+        line,
+        message: `not a question: ${r2.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ")}`
+      });
+      continue;
+    }
+    const bad = r2.data.evidence.find((e) => {
+      const file = e.slice(0, e.lastIndexOf(":"));
+      const n = Number(e.slice(e.lastIndexOf(":") + 1));
+      if (!insideRepo(file) || isSecretPath(file))
+        return true;
+      const text = source.read(file);
+      return text === void 0 || n < 1 || n > text.split(/\r?\n/).length;
+    });
+    if (bad) {
+      problems.push({ line, message: `its evidence ${bad} is no line of the repo` });
+      continue;
+    }
+    drafts.push(r2.data);
+  }
+  if (!drafts.length)
+    return { raised: [], known: [], problems };
+  const r = await raiseQuestions(root, drafts, {
+    step: "map",
+    repo,
+    command: by.command,
+    rerun: `atticus map ${repo}`,
+    ...by.run ? { run: by.run } : {},
+    at: by.at
+  });
+  return { raised: r.raised, known: [...r.known, ...r.reused], problems };
+}
+async function estateComponentsOf(root) {
+  const op = await loadOrgPack(orgPackDirOf(root)).catch(() => void 0);
+  const repos = (op?.profiles ?? []).flatMap((p) => p.repos?.repos ?? []);
+  if (!repos.length)
+    return void 0;
+  const components = repos.flatMap((r) => [
+    r.id,
+    ...r.component ? [r.component] : [],
+    ...(r.modules ?? []).map((m) => m.component)
+  ]);
+  const repoComponents = {};
+  for (const r of repos) {
+    const text = await readFile(join(factsDirOf(root), `${r.id}.jsonl`), "utf8").catch(() => void 0);
+    if (text === void 0)
+      continue;
+    const named = parseFactsLines(text).facts.flatMap((f) => f.component ? [f.component] : []);
+    repoComponents[r.id] = [
+      .../* @__PURE__ */ new Set([r.component ?? r.id, ...(r.modules ?? []).map((m) => m.component), ...named])
+    ].sort();
+  }
+  return { components: [...new Set(components)].sort(), repoComponents };
+}
+var SKIPPED_LISTED = 100;
+function slipNoteLines(slips, verifyYaml, shown = 5) {
+  if (!slips.length)
+    return [];
+  return [
+    `${slips.length} ${slips.length === 1 ? "slip" : "slips"} of form fixed in the facts (a note, not a rejection; under slips in ${verifyYaml}):`,
+    ...slips.slice(0, shown).map((x) => `  ${x.message}`),
+    ...slips.length > shown ? [`  ... and ${slips.length - shown} more (slips in ${verifyYaml})`] : []
+  ];
+}
+async function writeVerifyFiles(root, repo, report, commit, questionProblems = [], badLines = [], reviewedProblems = [], slips = []) {
+  const dir = factsDirOf(root);
+  await mkdir(dir, { recursive: true });
+  await writeFile(join(dir, `${repo}.jsonl`), serializeFacts(report.accepted), "utf8");
+  const rejectedFile = join(dir, `${repo}.rejected.jsonl`);
+  const lines = [
+    ...report.rejected.map((r) => JSON.stringify({ code: r.code, message: r.message, fact: r.fact })),
+    ...questionProblems.map((q) => JSON.stringify({ code: "bad-question", message: q.message, question: JSON.parse(q.line) })),
+    ...badLines.map((b) => JSON.stringify({ code: "schema", message: b.message, raw: b.raw })),
+    ...reviewedProblems.map((r) => JSON.stringify({ code: "bad-reviewed", message: r.message, reviewed: r.raw }))
+  ];
+  if (lines.length)
+    await writeFile(rejectedFile, lines.join("\n") + "\n", "utf8");
+  else
+    await rm(rejectedFile, { force: true });
+  const summary = {
+    repo,
+    ...commit ? { commit } : {},
+    accepted: report.accepted.length,
+    rejected: report.rejected.length,
+    redacted: report.redacted,
+    ...report.quotesDropped ? { quotesDropped: report.quotesDropped } : {},
+    coverage: {
+      ratio: report.coverage.ratio,
+      read: report.coverage.read.length,
+      ...report.coverage.reviewed.length ? { reviewed: report.coverage.reviewed.length } : {},
+      unknown: report.coverage.unknown,
+      excluded: report.coverage.excluded
+    },
+    rejections: report.rejected.map((r) => ({ id: r.fact.id, code: r.code, message: r.message })),
+    // ADR 0124 addendum D-app: a person's corrections, said only when there are some.
+    ...report.corrections.applied.length || report.corrections.stale.length ? {
+      corrections: {
+        applied: report.corrections.applied,
+        stale: report.corrections.stale.map((s) => ({
+          fact: s.correction.fact,
+          why: s.why,
+          message: s.message
+        }))
+      }
+    } : {}
+  };
+  if (report.carried.length) {
+    const by = /* @__PURE__ */ new Map();
+    for (const c of report.carried)
+      by.set(c.from, [...by.get(c.from) ?? [], c.id]);
+    summary.carried = [...by.entries()].sort((a, b) => a[0] < b[0] ? -1 : 1).map(([from, facts]) => ({ from, facts: facts.sort() }));
+  }
+  if (report.entriesNoFlowFollows.length)
+    summary.entriesNoFlowFollows = report.entriesNoFlowFollows;
+  if (report.reviewed.length)
+    summary.reviewed = report.reviewed;
+  if (report.reviewedDropped.length)
+    summary.reviewedDropped = report.reviewedDropped;
+  if (report.methodUnseen.length) {
+    summary.methodUnseenCount = report.methodUnseen.length;
+    summary.methodUnseen = report.methodUnseen;
+  }
+  if (report.skipped.length) {
+    summary.skippedCount = report.skipped.length;
+    summary.skipped = report.skipped.slice(0, SKIPPED_LISTED);
+  }
+  if (report.reviewedHolds.length)
+    summary.reviewedHolds = report.reviewedHolds;
+  if (report.specOpsUncovered.length) {
+    summary.specOpsUncoveredCount = report.specOpsUncovered.length;
+    summary.specOpsUncovered = report.specOpsUncovered.slice(0, SKIPPED_LISTED);
+  }
+  if (slips.length)
+    summary.slips = [...slips];
+  if (report.authUncited.length)
+    summary.authUncited = report.authUncited;
+  const fws = frameworkFacts(report.accepted);
+  if (fws.length)
+    summary.frameworks = fws.map((f) => ({
+      name: f.name,
+      ...f.version ? { version: f.version } : {},
+      cite: `${f.cite.file}:${f.cite.line}`,
+      ...f.component ? { component: f.component } : {}
+    }));
+  if (report.frameworkGaps.length)
+    summary.frameworkGaps = report.frameworkGaps;
+  await writeFile(join(dir, `${repo}.verify.yaml`), (0, import_yaml.stringify)(summary), "utf8");
+  return summary;
+}
+async function readCorrections(root, repo) {
+  const text = await readFile(join(factsDirOf(root), `${repo}.corrections.jsonl`), "utf8").catch(() => void 0);
+  return text === void 0 ? { corrections: [], bad: [] } : parseCorrections(text);
+}
+async function readReviewed(root, repo) {
+  const text = await readFile(join(factsDirOf(root), `${repo}.reviewed.jsonl`), "utf8").catch(() => void 0);
+  if (text === void 0)
+    return { entries: [], bad: [] };
+  const r = parseReviewed(text);
+  return {
+    entries: r.entries,
+    bad: r.bad.map((b) => ({ line: b.line, raw: b.raw, message: b.message }))
+  };
+}
+function reviewedProblemsOf(bad, report) {
+  return [
+    ...bad,
+    ...report.reviewedProblems.map((p) => ({
+      ...p.line !== void 0 ? { line: p.line } : {},
+      raw: { path: p.path, why: p.why },
+      message: p.message
+    }))
+  ].sort((a, b) => (a.line ?? 0) - (b.line ?? 0));
+}
+
+export {
+  checkoutOf,
+  headOf,
+  carryOf,
+  conventionsAt,
+  excludesOf,
+  raiseReadQuestions,
+  estateComponentsOf,
+  slipNoteLines,
+  writeVerifyFiles,
+  readCorrections,
+  readReviewed,
+  reviewedProblemsOf
+};

package/dist/chunk-B7434AE2.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 {
+  loadRepos
+} from "./chunk-PGKHJYOB.js";
+import {
+  changesDirOf,
+  checkedProposals,
+  isPersonsQuestion,
+  orderQuestions,
+  peopleOfChange,
+  questionWeights,
+  readTeams,
+  require_dist,
+  routeOfQuestion,
+  teamsOfPerson
+} from "./chunk-577AJVRS.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/question-routing.js
+var import_yaml = __toESM(require_dist(), 1);
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+async function changePeopleOf(root, id) {
+  const text = await readFile(join(changesDirOf(root), id, "change.yaml"), "utf8").catch(() => void 0);
+  if (text === void 0)
+    return [];
+  let data;
+  try {
+    data = (0, import_yaml.parse)(text);
+  } catch {
+    return [];
+  }
+  const owners = data?.owners;
+  if (!owners || typeof owners !== "object" || Array.isArray(owners))
+    return [];
+  const lists = {};
+  for (const [role, v] of Object.entries(owners))
+    if (Array.isArray(v))
+      lists[role] = v.filter((h) => typeof h === "string" && !!h.trim());
+  return peopleOfChange(lists);
+}
+async function routeQuestions(root, questions, o = {}) {
+  const problems = [];
+  const owners = /* @__PURE__ */ new Map();
+  try {
+    for (const r of await loadRepos(root))
+      owners.set(r.id, r.owner);
+  } catch (e) {
+    problems.push({
+      file: "org-pack/profiles",
+      message: e.message.split("\n")[0]
+    });
+  }
+  const { teams, problem } = await readTeams(root);
+  if (problem)
+    problems.push({ file: "org-pack/roles.yaml", message: problem });
+  const changes = new Set(await readdir(changesDirOf(root), { withFileTypes: true }).then((d) => d.filter((x) => x.isDirectory()).map((x) => x.name), () => []));
+  const changePeople = /* @__PURE__ */ new Map();
+  for (const id of new Set(questions.map((q) => q.repo)))
+    if (changes.has(id))
+      changePeople.set(id, await changePeopleOf(root, id));
+  const weights = await questionWeights(root, questions);
+  const proposals = new Map((await checkedProposals(root).catch(() => [])).filter((p) => p.ok && p.proposal).map((p) => [p.id, { ...p.proposal, file: p.file }]));
+  const about = {};
+  for (const q of questions) {
+    const p = q.state === "open" ? proposals.get(q.id) : void 0;
+    about[q.id] = {
+      ...weights.get(q.id) ?? { restsOn: [], joins: 0 },
+      owner: routeOfQuestion(q, { owners, teams, changes, changePeople }),
+      ...p ? {
+        proposal: {
+          answer: p.answer,
+          why: p.why,
+          cites: p.cites,
+          by: p.by,
+          at: p.at,
+          file: p.file
+        }
+      } : {}
+    };
+  }
+  let list = orderQuestions(questions, weights);
+  let me;
+  if (o.mine !== void 0) {
+    const mine = teamsOfPerson(o.mine, teams);
+    me = {
+      handle: o.mine,
+      teams: mine.map((t) => ({ id: t.id, ...t.name ? { name: t.name } : {} }))
+    };
+    const handle = o.mine;
+    list = list.filter((q) => isPersonsQuestion(handle, about[q.id].owner, teams));
+  }
+  return { questions: list, about, ...me ? { me } : {}, problems };
+}
+
+export {
+  routeQuestions
+};

package/dist/chunk-BDEKREZH.js

@@ -0,0 +1,155 @@
+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 {
+  addHistory,
+  historyEntry,
+  listHistory,
+  setLocalRecording
+} from "./chunk-MH5OCRUM.js";
+import {
+  api_exports
+} from "./chunk-577AJVRS.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/history-commands.js
+var when = (iso) => iso.replace("T", " ").slice(0, 16);
+var KB = api_exports.HISTORY_TEXT_MAX_BYTES / 1024;
+function firstLine(text, max = 120) {
+  const lines = text.split(/\r?\n/).filter((l) => l.trim());
+  const first = (lines[0] ?? "").trim();
+  const cut = first.length > max ? `${first.slice(0, max - 1)}\u2026` : first;
+  return lines.length > 1 && cut === first ? `${cut} \u2026` : cut;
+}
+function recordingLine(r) {
+  if (r.on)
+    return "Recording is on: prompts and responses in this metarepo are kept in .atticus/history/, on this machine only.";
+  return r.offBy === "org-pack" ? "Recording is off (runtime.yaml history.record is false)." : "Recording is off on this machine (atticus history on turns it back on).";
+}
+var offWhy = (r) => r.offBy === "org-pack" ? "runtime.yaml history.record is false" : "atticus history off";
+async function historyAddCli(root, o, readText, io) {
+  const surface = api_exports.HistorySurface.safeParse(o.surface);
+  if (!surface.success) {
+    io.err(`--surface is claude-code, vscode or cli${o.surface ? `, not ${o.surface}` : ""}.`);
+    return 2;
+  }
+  const kind = api_exports.HistoryKind.safeParse(o.kind);
+  if (!kind.success) {
+    io.err(`--kind is prompt or response${o.kind ? `, not ${o.kind}` : ""}.`);
+    return 2;
+  }
+  const text = await readText();
+  if (!text.trim()) {
+    io.out("Nothing to record: the text is empty.");
+    return 0;
+  }
+  const r = await addHistory(root, {
+    surface: surface.data,
+    kind: kind.data,
+    text,
+    ...o.session ? { session: o.session } : {},
+    ...o.command ? { command: o.command } : {},
+    ...o.change ? { change: o.change } : {}
+  });
+  if (r.off) {
+    io.out(`Recording is off (${offWhy(r.off)}); nothing was recorded.`);
+    return 0;
+  }
+  const notes = [
+    ...r.record.truncated ? [`cut at ${KB} KB`] : [],
+    ...r.record.masked ? ["parts that looked like a secret were masked"] : []
+  ];
+  io.out(`Recorded ${r.record.id} (${r.record.kind}, ${r.record.size} bytes${notes.length ? `; ${notes.join("; ")}` : ""}).`);
+  return 0;
+}
+async function historyOnOffCli(root, on, io) {
+  await setLocalRecording(root, on);
+  io.out(on ? "Recording is on on this machine (.atticus/me.yaml). runtime.yaml can still turn it off for everyone." : "Recording is off on this machine (.atticus/me.yaml): nothing more is kept. What was recorded stays in .atticus/history/.");
+  return 0;
+}
+async function historyCli(root, o, io) {
+  const list = await listHistory(root, {
+    ...o.change ? { change: o.change } : {},
+    ...o.session ? { session: o.session } : {},
+    ...o.filter ? { filter: o.filter } : {},
+    limit: o.limit ?? 50
+  });
+  if (o.json) {
+    io.out(JSON.stringify(list, null, 2));
+    return 0;
+  }
+  io.out(recordingLine(list.recording));
+  if (!list.turns.length) {
+    io.out(o.change || o.session || o.filter ? "No prompts match." : "No prompts yet. Claude Code's (with the Atticus plugin) and @atticus's in VS Code are recorded here; Copilot's other chats can't be.");
+    return 0;
+  }
+  const sessions = /* @__PURE__ */ new Map();
+  for (const t of list.turns) {
+    const k = `${t.surface}\0${t.session}`;
+    sessions.set(k, [...sessions.get(k) ?? [], t]);
+  }
+  const indent = " ".repeat(20);
+  for (const turns of sessions.values()) {
+    io.out("");
+    io.out(`Session ${turns[0].session} (${turns[0].surface})`);
+    for (const t of turns) {
+      const tag = t.change ? `  [${t.change}]` : "";
+      if (t.prompt)
+        io.out(`  ${when(t.at)}  you: ${firstLine(t.prompt.text)}${tag}  ${t.prompt.id}`);
+      if (t.response)
+        io.out(`${t.prompt ? indent : `  ${when(t.at)}  `}reply: ${firstLine(t.response.text)}${t.prompt ? "" : tag}  ${t.response.id}`);
+      else
+        io.out(`${indent}no response yet`);
+    }
+  }
+  if (list.total > list.turns.length)
+    io.out(`
+${list.total - list.turns.length} older turns not shown (--limit n shows more).`);
+  return 0;
+}
+function printRecord(r, io) {
+  for (const l of r.text.replace(/\s+$/, "").split(/\r?\n/))
+    io.out(`  ${l}`);
+}
+async function historyShowCli(root, id, o, io) {
+  const e = await historyEntry(root, id);
+  if (!e) {
+    io.err(`There is no record ${id}. atticus history lists them.`);
+    return 2;
+  }
+  if (o.json) {
+    io.out(JSON.stringify(e, null, 2));
+    return 0;
+  }
+  const r = e.record;
+  io.out([
+    `${r.id}: ${r.kind}`,
+    r.surface,
+    `session ${r.session}`,
+    when(r.at),
+    ...r.change ? [`change ${r.change}`] : [],
+    ...r.command ? [r.command] : [],
+    `${r.size} bytes`
+  ].join(", "));
+  if (r.truncated)
+    io.out(`Cut at ${KB} KB: the text was ${r.size} bytes.`);
+  if (r.masked)
+    io.out("Parts that looked like a secret were masked (***) before it was kept.");
+  printRecord(r, io);
+  if (e.pair) {
+    io.out(r.kind === "response" ? `In answer to ${e.pair.id}:` : `Answered by ${e.pair.id}:`);
+    printRecord(e.pair, io);
+  } else if (r.kind === "prompt")
+    io.out("No response yet.");
+  return 0;
+}
+export {
+  historyAddCli,
+  historyCli,
+  historyOnOffCli,
+  historyShowCli,
+  recordingLine
+};