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

package/dist/chunk-LVBPY2M6.js

@@ -0,0 +1,406 @@
+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-ASKDCMW5.js";
+import {
+  lineRangeOf
+} from "./chunk-XPWSNKF3.js";
+import {
+  citedFiles,
+  external_exports,
+  factsDirOf,
+  factsRelOf,
+  parseFacts,
+  require_dist
+} from "./chunk-JMOLB347.js";
+import {
+  writeFileAtomic
+} from "./chunk-MMB2OHUY.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 ReadStamp = external_exports.strictObject({ at: external_exports.string().min(1), commit: external_exports.string().min(1) });
+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(),
+  /** An estimate: the tokens the part's source counts as (`estimateTokens`), not a meter. */
+  tokens: external_exports.number().int().nonnegative(),
+  /** ADR 0141 (v2): when `atticus verify` first found every unit of the part in the facts. */
+  read: ReadStamp.optional()
+});
+var PlanV1 = external_exports.strictObject({
+  schemaVersion: external_exports.literal(1),
+  repo: external_exports.string().min(1),
+  commit: external_exports.string().min(1),
+  session: external_exports.number().int().positive(),
+  plannedAt: external_exports.string().min(1),
+  parts: external_exports.array(Part.omit({ read: true })).min(1)
+});
+var Reported = external_exports.strictObject({
+  at: external_exports.string().min(1),
+  /** The commit the read was of. */
+  commit: external_exports.string().min(1),
+  tokens: external_exports.number().int().positive().optional(),
+  sessions: external_exports.number().int().positive().optional(),
+  /** The part the report is for, when it is for one. */
+  part: external_exports.number().int().positive().optional(),
+  /** Who reported it (--by), when given. */
+  by: external_exports.string().min(1).optional()
+});
+var ReadPlanFile = external_exports.strictObject({
+  /** 2 since ADR 0141 (a v1 file reads as v2: `migrateReadPlan`). */
+  schemaVersion: external_exports.literal(2),
+  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 (`sessionTokensFor`). */
+  session: external_exports.number().int().positive(),
+  plannedAt: external_exports.string().min(1),
+  /**
+   * ADR 0141: what `--estimate` counted for the read (an estimate, not a meter): its source files
+   * and tokens, and the sessions planned (the parts, or one). `reread` when the read is of the
+   * files changed since the facts' commit only (addendum A-incremental).
+   */
+  estimate: external_exports.strictObject({
+    files: external_exports.number().int().nonnegative(),
+    tokens: external_exports.number().int().nonnegative(),
+    sessions: external_exports.number().int().positive(),
+    reread: external_exports.literal(true).optional()
+  }).optional(),
+  /** The parts in the order they are read; none for a repo one session reads (ADR 0141). */
+  parts: external_exports.array(Part),
+  /** ADR 0141: when `atticus verify` first found the whole plan in the facts. */
+  read: ReadStamp.extend({ sessions: external_exports.number().int().positive() }).optional(),
+  /** ADR 0141: what the reader reported the read took (`atticus map <repo> --spent`). */
+  reported: external_exports.array(Reported).optional()
+});
+function migrateReadPlan(raw) {
+  const v2 = ReadPlanFile.safeParse(raw);
+  if (v2.success)
+    return v2.data;
+  const v1 = PlanV1.safeParse(raw);
+  if (!v1.success)
+    return void 0;
+  return { ...v1.data, schemaVersion: 2 };
+}
+var readPlanRelOf = (root, repo) => `${factsRelOf(root)}/${repo}.read-plan.yaml`;
+var readPlanPath = (root, repo) => join(factsDirOf(root), `${repo}.read-plan.yaml`);
+function unitOf(glob) {
+  const range = lineRangeOf(glob);
+  if (range)
+    return { glob, dir: range.file.replace(/\/?[^/]*$/, ""), deep: false, range };
+  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}/`);
+function globHolds(glob, file) {
+  const u = unitOf(glob);
+  if (u.range)
+    return u.range.file === file;
+  if (!/[*]/.test(glob))
+    return glob === file;
+  const dir = file.replace(/\/?[^/]*$/, "");
+  return u.deep ? under(dir, u.dir) : dir === u.dir;
+}
+var HEADER = "# The parts this repo is read in (ADR 0124 addendum A-ledger), as atticus map --estimate planned them,\n# and what the read cost (ADR 0141): tokens are estimates, reported numbers are the reader's word.\n# Which part is next is read back from the facts; atticus next says it. Atticus writes this file.\n";
+async function saveReadPlan(root, plan) {
+  await writeFileAtomic(readPlanPath(root, plan.repo), `${HEADER}${(0, import_yaml.stringify)(ReadPlanFile.parse(plan), { lineWidth: 0 })}`);
+}
+async function writeReadPlan(root, repo, o) {
+  const plan = {
+    schemaVersion: 2,
+    repo,
+    commit: o.commit,
+    session: o.session,
+    plannedAt: o.now ?? stamp(),
+    ...o.estimate ? { estimate: o.estimate } : {},
+    parts: o.parts.map((p, i) => ({
+      part: i + 1,
+      paths: [...p.paths],
+      files: p.files,
+      tokens: p.tokens
+    })),
+    ...o.reported?.length ? { reported: [...o.reported] } : {}
+  };
+  await saveReadPlan(root, plan);
+  return plan;
+}
+var stamp = () => (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+async function loadReadPlan(root, repo) {
+  const text = await readFile(readPlanPath(root, repo), "utf8").catch(() => void 0);
+  if (text === void 0)
+    return void 0;
+  try {
+    return migrateReadPlan((0, import_yaml.parse)(text));
+  } catch {
+    return void 0;
+  }
+}
+function citedLines(x, out = []) {
+  if (Array.isArray(x))
+    for (const v of x)
+      citedLines(v, out);
+  else if (x && typeof x === "object") {
+    const o = x;
+    if (typeof o.file === "string" && typeof o.line === "number")
+      out.push({ file: o.file, line: o.line });
+    for (const v of Object.values(o))
+      if (v && typeof v === "object")
+        citedLines(v, out);
+  }
+  return out;
+}
+async function coveredOf(root, repo) {
+  const out = /* @__PURE__ */ new Set();
+  const reviewed = /* @__PURE__ */ new Set();
+  const lines = [];
+  const ranges = /* @__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);
+      citedLines(f, lines);
+    }
+  }
+  for (const e of (await readReviewed(root, repo)).entries)
+    if (lineRangeOf(e.path))
+      ranges.add(e.path);
+    else {
+      out.add(e.path);
+      reviewed.add(e.path);
+    }
+  return { paths: [...out], reviewed, lines, ranges };
+}
+async function readPlanProgress(root, repo, o = {}) {
+  const plan = await loadReadPlan(root, repo);
+  if (!plan || !plan.parts.length)
+    return void 0;
+  return progressOf(plan, await coveredOf(root, repo), o);
+}
+function ownStarts(plan) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const p of plan.parts)
+    for (const glob of p.paths) {
+      const r = lineRangeOf(glob);
+      if (r)
+        byFile.set(r.file, [...byFile.get(r.file) ?? [], { glob, from: r.from, to: r.to }]);
+    }
+  const out = /* @__PURE__ */ new Map();
+  for (const rs of byFile.values()) {
+    rs.sort((a, b) => a.from - b.from || a.to - b.to);
+    let end = 0;
+    for (const r of rs) {
+      out.set(r.glob, Math.min(r.to, Math.max(r.from, end + 1)));
+      end = Math.max(end, r.to);
+    }
+  }
+  return out;
+}
+function progressOf(plan, of, o) {
+  const repo = plan.repo;
+  const covered = of.paths.map(folderOf);
+  const own = ownStarts(plan);
+  const parts = plan.parts.map((p) => {
+    const units = p.paths.map(unitOf);
+    const hit = (u) => {
+      if (u.range) {
+        const r = u.range;
+        const start = own.get(u.glob) ?? r.from;
+        return of.ranges.has(u.glob) || of.lines.some((l) => l.file === r.file && l.line >= start && l.line <= r.to) || // The whole file reviewed, or a folder glob reviewed over it.
+        of.reviewed.has(r.file) || [...of.reviewed].some((c) => folderOf(c).deep && under(u.dir, folderOf(c).dir));
+      }
+      return 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}`;
+var sameCommit = (a, b) => a.startsWith(b) || b.startsWith(a);
+async function recordReadProgress(root, repo, o) {
+  const plan = await loadReadPlan(root, repo);
+  if (!plan || !o.commit || !sameCommit(plan.commit, o.commit))
+    return void 0;
+  const at = o.now ?? stamp();
+  const read = { at, commit: o.commit };
+  let changed = false;
+  let parts = plan.parts;
+  let whole = plan.parts.length === 0 && o.kept > 0;
+  if (plan.parts.length) {
+    const progress = progressOf(plan, await coveredOf(root, repo), {});
+    parts = plan.parts.map((p, i) => {
+      if (p.read || progress.parts[i].state !== "done")
+        return p;
+      changed = true;
+      return { ...p, read };
+    });
+    whole = parts.every((p) => p.read);
+  }
+  const next = {
+    ...plan,
+    parts,
+    ...whole && !plan.read ? { read: { ...read, sessions: plan.parts.length || 1 } } : plan.read ? { read: plan.read } : {}
+  };
+  if (whole && !plan.read)
+    changed = true;
+  if (!changed)
+    return plan;
+  await saveReadPlan(root, next);
+  return next;
+}
+async function recordReported(root, repo, r) {
+  const plan = await loadReadPlan(root, repo);
+  if (!plan)
+    return void 0;
+  const entry = {
+    at: r.at ?? stamp(),
+    commit: plan.commit,
+    ...r.tokens ? { tokens: r.tokens } : {},
+    ...r.sessions ? { sessions: r.sessions } : {},
+    ...r.part ? { part: r.part } : {},
+    ...r.by ? { by: r.by } : {}
+  };
+  const next = { ...plan, reported: [...plan.reported ?? [], entry] };
+  await saveReadPlan(root, next);
+  return next;
+}
+function readCostOf(plan) {
+  const ofCommit = (plan.reported ?? []).filter((r) => sameCommit(r.commit, plan.commit));
+  const sum = (k) => ofCommit.some((r) => r[k] !== void 0) ? ofCommit.reduce((n, r) => n + (r[k] ?? 0), 0) : void 0;
+  const tokens = sum("tokens");
+  const sessions = sum("sessions");
+  const of = plan.parts.length || 1;
+  return {
+    commit: plan.commit,
+    session: plan.session,
+    ...plan.estimate ? { estimated: plan.estimate } : {},
+    read: {
+      parts: plan.parts.length ? plan.parts.filter((p) => p.read).length : plan.read ? 1 : 0,
+      of,
+      ...plan.read ? { at: plan.read.at } : {}
+    },
+    ...ofCommit.length ? {
+      reported: {
+        ...tokens !== void 0 ? { tokens } : {},
+        ...sessions !== void 0 ? { sessions } : {},
+        reports: ofCommit.length
+      }
+    } : {}
+  };
+}
+var tokensWords = (n) => n >= 1e6 ? `${(n / 1e6).toFixed(1).replace(/\.0$/, "")}M` : n >= 1e3 ? `${Math.round(n / 1e3)}K` : String(n);
+function readCostWords(c) {
+  const out = [];
+  if (c.estimated)
+    out.push(`estimated about ${tokensWords(c.estimated.tokens)} tokens in ${c.estimated.sessions} session${c.estimated.sessions === 1 ? "" : "s"}${c.estimated.reread ? " (a re-read)" : ""}`);
+  if (c.read.of > 1 || c.read.parts)
+    out.push(c.read.at ? `read in ${c.read.of} part${c.read.of === 1 ? "" : "s"}` : `${c.read.parts} of ${c.read.of} part${c.read.of === 1 ? "" : "s"} read`);
+  if (c.reported)
+    out.push(`reported ${[
+      c.reported.tokens !== void 0 ? `${tokensWords(c.reported.tokens)} tokens` : "",
+      c.reported.sessions !== void 0 ? `${c.reported.sessions} session${c.reported.sessions === 1 ? "" : "s"}` : ""
+    ].filter(Boolean).join(" in ")}`);
+  return out.join("; ");
+}
+async function mapSpent(root, repo, o, io) {
+  const count = (v, what) => {
+    if (v === void 0)
+      return void 0;
+    const n = Number(v.replace(/[_,]/g, "").replace(/k$/i, "000"));
+    if (Number.isInteger(n) && n > 0)
+      return n;
+    io.err(`${what} is a whole number above 0 (got ${v}).`);
+    return false;
+  };
+  const tokens = count(o.spent, "--spent");
+  const sessions = count(o.sessions, "--sessions");
+  const part = count(o.part, "--part");
+  if (tokens === false || sessions === false || part === false)
+    return 2;
+  if (tokens === void 0 && sessions === void 0) {
+    io.err("Usage: atticus map <repo> --spent <tokens> [--sessions n] [--part n]");
+    return 2;
+  }
+  const plan = await loadReadPlan(root, repo);
+  if (!plan) {
+    io.err(`${repo} has no read plan (${readPlanRelOf(root, repo)}) to record it in: run atticus map ${repo} --estimate first; it records the estimate the read is compared with.`);
+    return 2;
+  }
+  if (part !== void 0 && !plan.parts.some((p) => p.part === part)) {
+    io.err(`${repo}'s read plan has ${plan.parts.length ? `parts 1 to ${plan.parts.length}` : "no parts (one session reads it)"}: there is no part ${part}.`);
+    return 2;
+  }
+  const next = await recordReported(root, repo, {
+    ...tokens ? { tokens } : {},
+    ...sessions ? { sessions } : {},
+    ...part ? { part } : {},
+    ...o.by ? { by: o.by } : {}
+  });
+  const cost = readCostOf(next);
+  io.out(`Recorded in ${readPlanRelOf(root, repo)}, as reported (Atticus meters nothing): ${readCostWords(cost)}.`);
+  return 0;
+}
+
+export {
+  ReadPlanFile,
+  migrateReadPlan,
+  readPlanRelOf,
+  globHolds,
+  saveReadPlan,
+  writeReadPlan,
+  loadReadPlan,
+  readPlanProgress,
+  ownStarts,
+  partOfWords,
+  recordReadProgress,
+  recordReported,
+  readCostOf,
+  tokensWords,
+  readCostWords,
+  mapSpent
+};

package/dist/chunk-LZWVK4YY.js

@@ -0,0 +1,169 @@
+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 {
+  QueryError,
+  askLookup,
+  impact,
+  openIndex,
+  runContextTool,
+  translate
+} from "./chunk-XNRPCI23.js";
+import "./chunk-BKFGGJKA.js";
+import "./chunk-JMOLB347.js";
+import "./chunk-MMB2OHUY.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/index-commands.js
+async function withIndex(root, io, fn, rebuild = false) {
+  const ix = await openIndex(root, { rebuild });
+  try {
+    for (const p of ix.problems)
+      io.err(`${p.file}: ${p.message} (left out of the index)`);
+    return fn(ix);
+  } finally {
+    ix.close();
+  }
+}
+async function askCommand(root, question, o, io) {
+  const asked = await withIndex(root, io, (ix) => {
+    return translate(question, askLookup(ix));
+  });
+  if (!o.json) {
+    io.out(asked.explanation);
+    io.out(`Query: ${asked.query}`);
+    io.out("");
+  }
+  if (asked.action === "impact")
+    return impactCommand(root, asked.id, { json: o.json === true }, io);
+  return queryCommand(root, asked.query, { json: o.json === true }, io);
+}
+async function queryCommand(root, q, o, io) {
+  return withIndex(root, io, (ix) => {
+    let res;
+    try {
+      res = ix.query(q, { limit: o.limit ?? 100 });
+    } catch (e) {
+      if (e instanceof QueryError) {
+        io.err(e.message);
+        return 2;
+      }
+      throw e;
+    }
+    if (o.json) {
+      io.out(JSON.stringify({ total: res.total, records: ix.records(res.rows) }, null, 2));
+      return 0;
+    }
+    if (res.rows.length > 0)
+      for (const l of table(["KIND", "ID", "NAME", "STATUS", "CONFIDENCE", "SYSTEM"], res.rows.map((r) => [r.kind, r.id, r.name, r.status, r.confidence, r.system ?? ""])))
+        io.out(l);
+    io.out(res.rows.length < res.total ? `${res.rows.length} of ${res.total} records (use --limit to see more)` : `${res.total} record${res.total === 1 ? "" : "s"}`);
+    return 0;
+  });
+}
+async function searchCommand(root, text, o, io) {
+  if (o.by && o.by !== "words") {
+    if (o.by !== "meaning" && o.by !== "both") {
+      io.err("--by is words, meaning or both.");
+      return 2;
+    }
+    const ix = await openIndex(root, { embedOnOpen: Number.MAX_SAFE_INTEGER });
+    try {
+      const kinds = o.kind?.split(",").map((k) => k.trim()).filter(Boolean);
+      io.out(await runContextTool(ix, root, "search", {
+        text,
+        by: o.by,
+        limit: Math.min(o.limit ?? 20, 20),
+        ...kinds?.length ? { kinds } : {}
+      }));
+      return 0;
+    } finally {
+      ix.close();
+    }
+  }
+  return withIndex(root, io, (ix) => {
+    const kinds = o.kind ? o.kind.split(",").map((k) => k.trim()).filter(Boolean) : void 0;
+    const hits = ix.search(text, { limit: o.limit ?? 20, ...kinds ? { kinds } : {} });
+    if (o.json) {
+      io.out(JSON.stringify({ total: hits.length, hits }, null, 2));
+      return 0;
+    }
+    if (hits.length > 0)
+      for (const l of table(["KIND", "ID", "NAME", "FILE"], hits.map((h) => [h.kind, h.id, h.name.slice(0, 60), h.file])))
+        io.out(l);
+    io.out(hits.length ? `${hits.length} hit${hits.length === 1 ? "" : "s"}, best first` : "Nothing in the index matches those words.");
+    return 0;
+  });
+}
+async function impactCommand(root, id, o, io) {
+  return withIndex(root, io, (ix) => {
+    const r = impact(ix, id, o.depth ?? 4);
+    if (!r) {
+      io.err(`No record with id "${id}" in the catalog. Try: atticus query ${id}`);
+      return 1;
+    }
+    if (o.json) {
+      io.out(JSON.stringify(r, null, 2));
+      return 0;
+    }
+    io.out(`Changing ${id} reaches ${r.affected.length} record${r.affected.length === 1 ? "" : "s"}:`);
+    if (r.affected.length > 0)
+      for (const l of table(["KIND", "ID", "OWNER", "WHY"], r.affected.map((a) => [a.kind, a.id, a.owner ?? "", a.reason])))
+        io.out(`  ${l}`);
+    if (r.gaps.length > 0) {
+      io.out("Open questions:");
+      for (const g of r.gaps)
+        io.out(`  - ${g.question} (${g.record})`);
+    }
+    return 0;
+  });
+}
+async function indexEmbed(root, io) {
+  const ix = await openIndex(root, { embedOnOpen: 0 });
+  try {
+    const before = ix.meaning();
+    if (!ix.embedder) {
+      io.err(`${before.note}. Set retrieval.embeddings.model in the org pack's runtime.yaml.`);
+      return 1;
+    }
+    let last = Date.now();
+    const n = await ix.embed({
+      progress: (done, of) => {
+        if (Date.now() - last > 5e3 || done === of) {
+          io.out(`Embedded ${done} of ${of}`);
+          last = Date.now();
+        }
+      }
+    });
+    const after = ix.meaning();
+    io.out(`${n ? `Embedded ${n} new text${n === 1 ? "" : "s"}. ` : ""}${after.note}.`);
+    return after.on ? 0 : 1;
+  } catch (e) {
+    io.err(`The embedding model couldn't run: ${e.message.split("\n")[0]}`);
+    return 1;
+  } finally {
+    ix.close();
+  }
+}
+async function indexRebuild(root, io) {
+  return withIndex(root, io, (ix) => {
+    const kinds = ix.kinds();
+    const total = kinds.reduce((n, k) => n + k.count, 0);
+    io.out(`Indexed ${total} records of ${kinds.length} kinds into ${ix.file}`);
+    return ix.problems.length > 0 ? 1 : 0;
+  }, true);
+}
+export {
+  askCommand,
+  impactCommand,
+  indexEmbed,
+  indexRebuild,
+  queryCommand,
+  searchCommand,
+  table
+};

package/dist/chunk-MCWWMMLN.js

@@ -0,0 +1,48 @@
+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 {
+  MIN_GIT,
+  MIN_NODE,
+  doctorChecks,
+  doctorCommand,
+  stepModelChoices,
+  stepModelLine
+} from "./chunk-WCLAOKCH.js";
+import "./chunk-3G4YI4ZU.js";
+import "./chunk-LUPW4WLK.js";
+import "./chunk-NG5R2WIY.js";
+import "./chunk-6RGIM2ZH.js";
+import "./chunk-EV4TEFOD.js";
+import "./chunk-6N2GUZMZ.js";
+import "./chunk-T6ESD5KM.js";
+import "./chunk-3LU6YCSQ.js";
+import "./chunk-L7I5PKGD.js";
+import "./chunk-CAN3EBE5.js";
+import "./chunk-IILZ7J3L.js";
+import "./chunk-TEBBD4XH.js";
+import "./chunk-XPWSNKF3.js";
+import "./chunk-WIMOJMAK.js";
+import "./chunk-5V5BJACL.js";
+import "./chunk-GVFUEGGM.js";
+import "./chunk-XNRPCI23.js";
+import {
+  versionAtLeast
+} from "./chunk-7RUMD56V.js";
+import "./chunk-XZJE6WIT.js";
+import "./chunk-FMRMTI7W.js";
+import "./chunk-BKFGGJKA.js";
+import "./chunk-JMOLB347.js";
+import "./chunk-MMB2OHUY.js";
+import "./chunk-TV45EUGM.js";
+export {
+  MIN_GIT,
+  MIN_NODE,
+  doctorChecks,
+  doctorCommand,
+  stepModelChoices,
+  stepModelLine,
+  versionAtLeast
+};

package/dist/chunk-MKC7P5LD.js

@@ -0,0 +1,32 @@
+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 {
+  catalogRecords,
+  guideCommand,
+  openChanges,
+  siteBuildCommand
+} from "./chunk-HR4DVO6X.js";
+import "./chunk-3LU6YCSQ.js";
+import "./chunk-L7I5PKGD.js";
+import "./chunk-CAN3EBE5.js";
+import "./chunk-IILZ7J3L.js";
+import "./chunk-TEBBD4XH.js";
+import "./chunk-XPWSNKF3.js";
+import "./chunk-WIMOJMAK.js";
+import "./chunk-5V5BJACL.js";
+import "./chunk-GVFUEGGM.js";
+import "./chunk-XZJE6WIT.js";
+import "./chunk-FMRMTI7W.js";
+import "./chunk-BKFGGJKA.js";
+import "./chunk-JMOLB347.js";
+import "./chunk-MMB2OHUY.js";
+import "./chunk-TV45EUGM.js";
+export {
+  catalogRecords,
+  guideCommand,
+  openChanges,
+  siteBuildCommand
+};

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