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

package/dist/chunk-7DUDLVFJ.js

@@ -0,0 +1,52 @@
+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 {
+  captureLine,
+  changeArchive,
+  changeConflicts,
+  changeHandoff,
+  changeLearn,
+  changeList,
+  changeNew,
+  changeReturn,
+  changeStatus,
+  changeSync,
+  parseOwners
+} from "./chunk-4PJADZRR.js";
+import "./chunk-23M2LUYM.js";
+import "./chunk-KC5DROFC.js";
+import "./chunk-RK6MKKKP.js";
+import "./chunk-VOGCSYOI.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 {
+  captureLine,
+  changeArchive,
+  changeConflicts,
+  changeHandoff,
+  changeLearn,
+  changeList,
+  changeNew,
+  changeReturn,
+  changeStatus,
+  changeSync,
+  parseOwners
+};

package/dist/chunk-7EFILTCI.js

@@ -0,0 +1,67 @@
+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/flags.js
+function flagNames(argv) {
+  const out = [];
+  for (const a of argv) {
+    if (a === "--")
+      break;
+    if (a.startsWith("--") && a.length > 2)
+      out.push(a.slice(2).split("=")[0]);
+  }
+  return out;
+}
+function unknownFlags(argv, known) {
+  return [...new Set(flagNames(argv).filter((f) => !known.has(f)))];
+}
+function distance(a, b) {
+  const d = Array.from({ length: a.length + 1 }, (_, i) => Array.from({ length: b.length + 1 }, (_2, j) => i === 0 ? j : j === 0 ? i : 0));
+  for (let i = 1; i <= a.length; i++)
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
+      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1])
+        d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
+    }
+  return d[a.length][b.length];
+}
+function nearest(word, candidates) {
+  const w = word.toLowerCase();
+  const flat = (s) => s.replace(/[-_\s]/g, "");
+  const limit = w.length <= 4 ? 1 : w.length <= 8 ? 2 : 3;
+  let best;
+  for (const c of candidates) {
+    const d = flat(c) === flat(w) ? 0 : distance(w, c.toLowerCase());
+    if (d <= limit && (!best || d < best.d || d === best.d && c < best.c))
+      best = { c, d };
+  }
+  return best?.c;
+}
+function unknownFlagMessages(unknown, known) {
+  return unknown.map((f) => {
+    const n = nearest(f, known);
+    return n ? `Unknown option --${f}. Did you mean --${n}?` : `Unknown option --${f}.`;
+  });
+}
+function nearestCommand(words, ids) {
+  const given = words.slice(0, 2).join(" ");
+  if (!given)
+    return void 0;
+  const two = ids.filter((id) => id.split(" ").length >= 2).map((id) => id.split(" ").slice(0, 2).join(" "));
+  const one = ids.map((id) => id.split(" ")[0]);
+  const pool = words.length >= 2 ? [...new Set(two)] : [...new Set(one)];
+  return nearest(given, pool) ?? (words.length >= 2 ? nearest(words[0], new Set(one)) : void 0);
+}
+
+export {
+  flagNames,
+  unknownFlags,
+  distance,
+  nearest,
+  unknownFlagMessages,
+  nearestCommand
+};

package/dist/chunk-7EKESFWV.js

@@ -0,0 +1,130 @@
+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 {
+  estateFacts,
+  measureLinks,
+  parseLinkReference
+} from "./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-PGKHJYOB.js";
+import "./chunk-MKRBG5EF.js";
+import "./chunk-5XDNUJ4P.js";
+import {
+  loadOrgPack,
+  orgPackDirOf
+} from "./chunk-577AJVRS.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/measure-commands.js
+import { readFile } from "node:fs/promises";
+import { isAbsolute, resolve } from "node:path";
+var MEASURE_WORDS = {
+  usage: "Usage: atticus join measure <reference.yaml> [--json] (docs/guide/measure.md)",
+  noFile: (file) => `There is no reference file at ${file}. List a few known repos' entries and calls in it (docs/guide/measure.md), then run atticus join measure again.`,
+  badFile: (file) => `${file} isn't a reference Atticus can read:`,
+  nothing: (file) => `${file} lists no calls or entries, so there is nothing to measure. List a few known repos' entries and calls (docs/guide/measure.md).`,
+  head: (file, m, repos) => `Measured against ${file}${m.estate ? ` (${m.estate})` : ""}: ${plural(repos, "repo")}, ${plural(m.reading.entries.want, "entry", "entries")} and ${plural(m.reading.calls.want, "call")} listed.`,
+  reading: (m) => `Reading: ${m.reading.entries.found} of ${plural(m.reading.entries.want, "entry", "entries")} and ${m.reading.calls.found} of ${plural(m.reading.calls.want, "call")} are in the facts${pct(m.reading.entries.found + m.reading.calls.found, m.reading.entries.want + m.reading.calls.want)}.`,
+  precision: (m) => m.links.precision === null ? "Join precision: no listed call is joined to a repo yet." : `Join precision ${m.links.precision}: ${m.links.right} of the ${plural(m.links.joined, "listed call")} joined to a repo reach the one you named.`,
+  recall: (m) => m.links.recall === null ? "Join recall: no listed call should reach a repo of the estate." : `Join recall ${m.links.recall}: ${m.links.right} of the ${plural(m.links.want, "call")} that should reach a repo of the estate do.`,
+  rest: (m) => [
+    `${m.links.asked} asked`,
+    `${m.links.inferred.joined} guessed (${m.links.inferred.right} right)`,
+    `${m.links.outside.right} of ${m.links.outside.want} outside right`,
+    ...m.links.none.want ? [`${m.links.none.right} of ${m.links.none.want} "none" right`] : [],
+    `${m.links.unlinked} unlinked`,
+    ...m.links.missed ? [`${m.links.missed} with no entry serving them`] : [],
+    `${m.links.notRead} not read`
+  ].join(", ") + ".",
+  calls: "Each listed call:",
+  missed: "Listed but not in the facts (read the repo again, or check the line and path you wrote):",
+  readOnly: "Nothing was written."
+};
+var plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+var pct = (a, b) => b ? ` (${Math.round(a / b * 100)}%)` : "";
+var wantText = (w) => "repo" in w ? w.repo : "outside" in w ? `outside ${w.outside}` : "none";
+function gotText(g) {
+  switch (g.kind) {
+    case "joined":
+      return `${g.repo} ${g.entry}${g.via?.length ? ` via ${g.via.join(", ")}` : ""}${g.inferred ? ` (a guess: ${g.inferred})` : ""}`;
+    case "outside":
+      return `outside ${g.system}`;
+    case "asked":
+      return `asked (${g.reason}): atticus questions`;
+    case "missed":
+      return `named ${g.target}, which serves nothing like it`;
+    case "unlinked":
+      return "nothing";
+    case "not-read":
+      return "not in the facts";
+  }
+}
+async function joinMeasure(root, file, o, io) {
+  if (!file) {
+    io.err(MEASURE_WORDS.usage);
+    return 2;
+  }
+  const path = isAbsolute(file) ? file : resolve(root, file);
+  const text = await readFile(path, "utf8").catch(() => void 0);
+  if (text === void 0) {
+    io.err(MEASURE_WORDS.noFile(file));
+    return 2;
+  }
+  const parsed = parseLinkReference(text);
+  if (!parsed.ok) {
+    io.err(MEASURE_WORDS.badFile(file));
+    for (const i of parsed.issues)
+      io.err(`  ${i}`);
+    return 2;
+  }
+  const ref = parsed.reference;
+  if (!ref.repos.some((r) => r.calls.length || r.entries.length)) {
+    io.err(MEASURE_WORDS.nothing(file));
+    return 2;
+  }
+  const op = await loadOrgPack(orgPackDirOf(root));
+  const estate = await estateFacts(root, op, "");
+  const m = measureLinks({ op, repos: estate.repos, targets: estate.targets, reference: ref });
+  const notes = [...estate.notes, ...m.notes];
+  if (o.json) {
+    io.out(JSON.stringify({ reference: file, ...m, notes }, null, 2));
+    return 0;
+  }
+  io.out(MEASURE_WORDS.head(file, m, ref.repos.length));
+  io.out(MEASURE_WORDS.reading(m));
+  io.out(MEASURE_WORDS.precision(m));
+  io.out(MEASURE_WORDS.recall(m));
+  io.out(MEASURE_WORDS.rest(m));
+  if (m.calls.length) {
+    io.out("");
+    io.out(MEASURE_WORDS.calls);
+    for (const c of m.calls)
+      io.out(`  ${c.right ? "ok" : "--"}  ${c.repo} ${c.call}: wanted ${wantText(c.want)}, got ${gotText(c.got)}`);
+  }
+  if (m.reading.missed.length) {
+    io.out("");
+    io.out(MEASURE_WORDS.missed);
+    for (const x of m.reading.missed)
+      io.out(`  ${x}`);
+  }
+  if (notes.length) {
+    io.out("");
+    for (const n of notes)
+      io.out(n);
+  }
+  io.out("");
+  io.out(MEASURE_WORDS.readOnly);
+  return 0;
+}
+export {
+  MEASURE_WORDS,
+  joinMeasure
+};

package/dist/chunk-7F2RUWPU.js

@@ -0,0 +1,101 @@
+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 {
+  parseFactLine
+} from "./chunk-577AJVRS.js";
+
+// packages/cli/dist/memory-room.js
+import { createReadStream } from "node:fs";
+import { createInterface } from "node:readline";
+import { freemem } from "node:os";
+import { getHeapStatistics } from "node:v8";
+var NoRoomError = class extends Error {
+  usedMB;
+  ceilingMB;
+  constructor(what, usedMB, ceilingMB) {
+    super(`${what} need more memory than Node was given: ${usedMB} MB of the ${ceilingMB} MB ceiling is in use. Run it again with ATTICUS_MAX_OLD_SPACE=${Math.max(4096, ceilingMB * 2)} (megabytes Node may use for the heap), or in parts, a repo at a time. Closing an IDE frees the memory this needs.`);
+    this.name = "NoRoomError";
+    this.usedMB = usedMB;
+    this.ceilingMB = ceilingMB;
+  }
+};
+var MB = 1024 * 1024;
+var SHARE = 0.8;
+function ceilingOf(env = process.env) {
+  const heap = getHeapStatistics().heap_size_limit;
+  const asked = Number(env.ATTICUS_MAX_OLD_SPACE);
+  const limit = Number.isFinite(asked) && asked > 0 ? Math.min(heap, asked * MB) : heap;
+  const free = freemem();
+  return free > 0 ? Math.min(limit, free + process.memoryUsage.rss()) : limit;
+}
+function roomGuard(o) {
+  const ceiling = o.ceilingBytes ?? ceilingOf();
+  const every = o.every ?? 32;
+  const used = o.used ?? (() => process.memoryUsage.rss());
+  const bar = ceiling * SHARE;
+  let n = 0;
+  return () => {
+    if (n++ % every !== 0)
+      return;
+    const now = used();
+    if (now <= bar)
+      return;
+    throw new NoRoomError(o.what, Math.round(now / MB), Math.max(1, Math.round(ceiling / MB)));
+  };
+}
+function maxOldSpaceIn(args) {
+  for (const a of args) {
+    const m = /^--max[-_]old[-_]space[-_]size[= ](\d+)$/.exec(a.trim());
+    if (m)
+      return Number(m[1]);
+  }
+  return void 0;
+}
+function reExecForMemory(env, execArgv) {
+  if (env.ATTICUS_RESTARTED_FOR_MEMORY)
+    return void 0;
+  const mb = Number(env.ATTICUS_MAX_OLD_SPACE);
+  if (!Number.isInteger(mb) || mb < 256 || mb > 1048576)
+    return void 0;
+  const already = [
+    maxOldSpaceIn(execArgv),
+    maxOldSpaceIn((env.NODE_OPTIONS ?? "").split(/\s+/))
+  ].filter((n) => n !== void 0);
+  if (already.length && Math.max(...already) >= mb)
+    return void 0;
+  return { maxOldSpaceMB: mb };
+}
+async function streamFacts(file, room) {
+  const facts = [];
+  const bad = [];
+  const seen = /* @__PURE__ */ new Set();
+  const lines = createInterface({
+    input: createReadStream(file, { encoding: "utf8" }),
+    crlfDelay: Infinity
+  });
+  let line = 0;
+  try {
+    for await (const raw of lines) {
+      room?.();
+      const r = parseFactLine(raw, ++line, seen);
+      if (r.fact)
+        facts.push(r.fact);
+      else if (r.bad)
+        bad.push(r.bad);
+    }
+  } finally {
+    lines.close();
+  }
+  return { facts, bad };
+}
+
+export {
+  NoRoomError,
+  ceilingOf,
+  roomGuard,
+  reExecForMemory,
+  streamFacts
+};