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

package/dist/chunk-OIK5YPTN.js

@@ -0,0 +1,391 @@
+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 {
+  upgradeCommand
+} from "./chunk-72TXNLOC.js";
+import {
+  AdoptError,
+  absorb,
+  acceptAbsorbed,
+  adopt,
+  checkZeroInstall,
+  init,
+  refreshAbsorbed,
+  refreshAllAbsorbed,
+  reposDiscover,
+  unadopt,
+  zeroInstallFiles
+} from "./chunk-IQFTZ37C.js";
+import {
+  assistantTier,
+  readProbes,
+  tierLine
+} from "./chunk-V5PKHHQQ.js";
+import "./chunk-VPTTCYOC.js";
+import "./chunk-L6SGQIR3.js";
+import "./chunk-7UFQZXZA.js";
+import "./chunk-56YQ6ROQ.js";
+import "./chunk-4AK7IBVP.js";
+import "./chunk-7JUKDRSZ.js";
+import "./chunk-OLWFG75W.js";
+import "./chunk-L24C55VN.js";
+import "./chunk-PAMPPUR6.js";
+import "./chunk-23W7VWKR.js";
+import "./chunk-7EKXJZ2Y.js";
+import "./chunk-MC3H7736.js";
+import "./chunk-T6AIP7H5.js";
+import "./chunk-JPGCERE2.js";
+import "./chunk-KJPMEAI4.js";
+import "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import {
+  loadOrgPack,
+  orgPackDirOf
+} from "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/setup-commands.js
+import { resolve } from "node:path";
+async function tierAt(root, io) {
+  try {
+    const op = await loadOrgPack(orgPackDirOf(root));
+    const { results } = await readProbes(root);
+    io.out(`Your assistant reads a repo at: ${tierLine(assistantTier(op.runtime, { probes: results }))}`);
+  } catch {
+  }
+}
+var plural = (n, w) => `${n} ${w}${n === 1 ? "" : "s"}`;
+function fail(io, e) {
+  if (e instanceof AdoptError) {
+    io.err(e.message);
+    return e.code === "usage" ? 2 : 1;
+  }
+  io.err(e.message);
+  return 1;
+}
+async function initCommand(dir, o, io) {
+  if (!o.name || !o.platform) {
+    io.err("Usage: atticus init <name> --platform <platform> [--from <org pack folder>]");
+    return 2;
+  }
+  try {
+    const r = await init(dir, {
+      name: o.name,
+      platform: o.platform,
+      ...o.packFrom ? { packFrom: resolve(o.packFrom) } : {},
+      ...o.owner ? { owner: o.owner } : {},
+      ...o.openspecStore ? { openspecStore: true } : {}
+    });
+    if (!r.problems.length)
+      await upgradeCommand(dir, o.owner ? { by: o.owner } : {}, {
+        out: () => void 0,
+        err: (l) => io.err(l)
+      });
+    if (o.json) {
+      io.out(JSON.stringify(r, null, 2));
+      return r.problems.length ? 1 : 0;
+    }
+    io.out(`Created the ${o.name} metarepo in ${dir} (${plural(r.created.length, "file")}).`);
+    if (r.git === "initialised")
+      io.out(`Made ${dir} a git repository (git init, branch main).`);
+    if (r.gitNote)
+      io.err(r.gitNote);
+    io.out(r.openspec === "cli" ? "OpenSpec is set up with the org-flow schema." : "openspec/ was made as folders with the org-flow schema.");
+    if (r.openspecNote)
+      io.out(r.openspecNote);
+    if (r.assistantFiles > 0)
+      io.out(`Your assistant's files are written (${r.assistantFiles} of them, .claude/commands/, .github/prompts/, CLAUDE.md), so /atticus-map works here; atticus assistant-files writes them again when the org pack changes.`);
+    else
+      io.out("Your assistant's files weren't written; run atticus assistant-files to get the slash commands (/atticus-map and the rest), or use atticus map <repo> instead.");
+    if (r.openspecStore)
+      io.out(`It is also the OpenSpec store ${r.openspecStore.id} (beta, .openspec-store/store.yaml): once it is pushed, a developer runs openspec store register <their clone> to use it from plain OpenSpec.`);
+    for (const p of r.problems)
+      io.err(`org-pack/${p.file}: ${p.path ? `${p.path}: ` : ""}${p.message}`);
+    for (const q of r.questions)
+      io.out(`Question: ${q}`);
+    await tierAt(dir, io);
+    io.out("Next: atticus repos discover <folder of clones> and atticus workspace sync, then read each repo: /atticus-map <repo> in your assistant (or atticus map <repo>), then atticus verify <repo> --write.");
+    return r.problems.length ? 1 : 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function adoptCommand(path, o, io) {
+  try {
+    const r = await adopt(path, {
+      ...o.platform ? { platform: o.platform } : {},
+      ...o.name ? { name: o.name } : {}
+    });
+    if (o.json) {
+      io.out(JSON.stringify({
+        root: r.root,
+        platform: r.platform,
+        detected: r.detected,
+        layout: r.layout,
+        repos: r.repos.map((x) => ({ ...x.entry, signals: x.detection.signals })),
+        questions: r.questions,
+        written: r.written,
+        problems: r.problems,
+        ms: r.ms
+      }, null, 2));
+      return r.problems.length ? 1 : 0;
+    }
+    const d = r.detected;
+    const found = [
+      d.openspec ? `OpenSpec in ${d.openspec}/` : void 0,
+      d.speckit ? "Spec Kit (.specify/)" : void 0,
+      d.constitution ? `a constitution (${d.constitution})` : void 0,
+      d.prompts.length ? `prompts in ${d.prompts.join(", ")}` : void 0,
+      d.agents.length ? `agents in ${d.agents.join(", ")}` : void 0,
+      d.skills.length ? `skills in ${d.skills.join(", ")}` : void 0,
+      d.catalog ? `a catalog in ${d.catalog}/` : void 0
+    ].filter(Boolean);
+    io.out(`Adopted ${r.root} in place in ${(r.ms / 1e3).toFixed(1)} s. No file of the repo was changed.`);
+    io.out(found.length ? `Found ${found.join("; ")}.` : "Found no OpenSpec, Spec Kit or assistant files.");
+    io.out(`Repos: ${r.repos.map((x) => `${x.entry.id} (${x.entry.type})`).join(", ") || "none"}.`);
+    io.out(`Everything Atticus owns is in .atticus/: the org pack points at what exists (openspec: ${r.layout.openspec}, catalog: ${r.layout.catalog}).`);
+    for (const p of r.problems)
+      io.err(`.atticus/org-pack/${p.file}: ${p.path ? `${p.path}: ` : ""}${p.message}`);
+    if (r.questions.length)
+      io.out(`${plural(r.questions.length, "question")} for people are in .atticus/proposals/repos/${r.platform}/QUESTIONS.md.`);
+    await tierAt(r.root, io);
+    io.out(`Next: atticus scan --root ${path}. To remove Atticus: atticus unadopt ${path}.`);
+    return r.problems.length ? 1 : 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function unadoptCommand(path, io) {
+  try {
+    const r = await unadopt(path);
+    for (const f of r.removed)
+      io.out(`Removed ${f}`);
+    for (const f of r.restored)
+      io.out(`Took Atticus's section out of ${f}`);
+    for (const f of r.keptNew)
+      io.out(`Kept ${f} (added since adoption, not Atticus's)`);
+    for (const f of r.changed)
+      io.out(`Kept ${f} (changed since adoption)`);
+    for (const f of r.missing)
+      io.out(`Note: ${f} was deleted since adoption`);
+    if (!r.hadSnapshot)
+      io.out("There was no adoption snapshot, so only files that are certainly Atticus's were removed.");
+    io.out(r.changed.length || r.keptNew.length || r.missing.length ? "Atticus is removed. The files above changed after adoption and were left as they are." : "Atticus is removed; every other file is as it was before adoption.");
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function reposDiscoverCommand(root, o, io) {
+  if (!o.from && !o.org) {
+    io.err("Usage: atticus repos discover <folder of clones> | --org <organisation>");
+    return 2;
+  }
+  if (o.org && !o.host) {
+    io.err("Listing an organisation needs a Git host adapter that can list repos, and none is configured. Point at a folder of clones instead.");
+    return 2;
+  }
+  try {
+    const r = await reposDiscover(root, o.org ? { host: o.host, org: o.org } : { dir: resolve(o.from) }, { ...o.platform ? { platform: o.platform } : {}, ...o.dryRun ? { dryRun: true } : {} });
+    if (o.json) {
+      io.out(JSON.stringify({
+        platform: r.platform,
+        repos: r.repos.map((x) => ({ ...x.entry, signals: x.detection.signals })),
+        skipped: r.skipped,
+        questions: r.questions,
+        wrote: r.wrote,
+        file: r.file
+      }, null, 2));
+      return 0;
+    }
+    for (const x of r.repos)
+      io.out(`  ${x.entry.id}: ${x.entry.type}${x.detection.signals[0] ? ` (${x.detection.signals[0]})` : ""}`);
+    for (const s of r.skipped)
+      io.out(`  Skipped ${s.path}: ${s.reason}`);
+    io.out(r.wrote === "manifest" ? `Wrote ${plural(r.repos.length, "repo")} to ${r.file}.` : r.wrote === "proposal" ? `A manifest exists, so it was left as it is; the proposal is in ${r.file}.` : `Found ${plural(r.repos.length, "repo")}; nothing written (dry run).`);
+    if (o.from && r.wrote === "manifest" && r.repos.length)
+      io.out(`Next: atticus workspace sync --from "${resolve(o.from)}" copies each repo from these clones, with no network.`);
+    if (r.questions.length)
+      io.out(`${plural(r.questions.length, "question")} need a person${r.questionsFile ? `: ${r.questionsFile}` : ""}.`);
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+function reportRefresh(r, io) {
+  const s = r.source;
+  const i = r.items;
+  if (!s.added.length && !s.removed.length && !s.changed.length && !i.added.length && !i.removed.length && !i.changed.length) {
+    io.out(`Refreshed ${r.id} from ${r.entry.url}: nothing changed since the last absorb.`);
+    return;
+  }
+  io.out(`Refreshed ${r.id} from ${r.entry.url}: ${plural(s.added.length, "file")} added, ${s.removed.length} removed and ${s.changed.length} changed in the source.`);
+  for (const f of s.added)
+    io.out(`  + ${f}`);
+  for (const f of s.removed)
+    io.out(`  - ${f}`);
+  for (const f of s.changed)
+    io.out(`  ~ ${f}`);
+  io.out(`Items: ${i.added.length} new, ${i.removed.length} gone, ${i.changed.length} with a different action.`);
+  for (const x of i.added)
+    io.out(`  + ${x}`);
+  for (const x of i.removed)
+    io.out(`  - ${x}`);
+  for (const x of i.changed)
+    io.out(`  ~ ${x.id}: ${x.from} to ${x.to}`);
+  if (r.result.proposal)
+    io.out(`Rewrote the proposal in ${r.result.proposal}/; review it as before.`);
+}
+async function absorbRefreshCommand(root, id, o, io) {
+  if (!id) {
+    io.err("Usage: atticus absorb --refresh <id>");
+    return 2;
+  }
+  try {
+    const r = await refreshAbsorbed(root, id);
+    if (o.json)
+      io.out(JSON.stringify({
+        id: r.id,
+        entry: r.entry,
+        source: r.source,
+        files: r.files,
+        items: r.items,
+        proposal: r.result.proposal
+      }, null, 2));
+    else
+      reportRefresh(r, io);
+    for (const p of r.result.problems)
+      io.err(`  ${p}`);
+    return r.result.problems.length ? 1 : 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function sourcesRefreshCommand(root, o, io) {
+  try {
+    const all = await refreshAllAbsorbed(root);
+    if (o.json)
+      io.out(JSON.stringify(all.map((r) => ({ id: r.id, source: r.source, files: r.files, items: r.items })), null, 2));
+    else if (!all.length)
+      io.out("No linked absorbed sources in sources.yaml; nothing to refresh.");
+    else
+      for (const r of all)
+        reportRefresh(r, io);
+    const problems = all.flatMap((r) => r.result.problems.map((p) => `${r.id}: ${p}`));
+    for (const p of problems)
+      io.err(`  ${p}`);
+    return problems.length ? 1 : 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function absorbAcceptCommand(root, id, o, io) {
+  if (!id) {
+    io.err("Usage: atticus absorb accept <id> [--replace] [--dry-run]");
+    return 2;
+  }
+  try {
+    const r = await acceptAbsorbed(root, id, {
+      ...o.replace ? { replace: true } : {},
+      ...o.dryRun ? { dryRun: true } : {}
+    });
+    if (o.json) {
+      io.out(JSON.stringify({ ...r, dryRun: o.dryRun === true }, null, 2));
+      return 0;
+    }
+    const would = o.dryRun ? "Would copy" : "Copied";
+    io.out(`${would} ${plural(r.copied.length, "file")} from ${r.proposal}/ into the metarepo${r.same.length ? ` (${r.same.length} already there)` : ""}; ${plural(r.linked, "item")} stay linked.`);
+    for (const f of r.copied)
+      io.out(`  ${f}`);
+    if (r.kept.length) {
+      io.out(`Kept ${plural(r.kept.length, "file")} that already differ (--replace overwrites them):`);
+      for (const f of r.kept)
+        io.out(`  ${f}`);
+    }
+    io.out(r.entry === "already" ? `${r.sourcesFile} already lists ${id}.` : `${o.dryRun ? "Would add" : r.entry === "added" ? "Added" : "Replaced"} ${id} under absorbed: in ${r.sourcesFile}.`);
+    if (!o.dryRun && (r.copied.length || r.entry !== "already"))
+      io.out("Commit these through a pull request: merging it is the approval.");
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function absorbCommand(root, url, o, io) {
+  if (!url || !o.id) {
+    io.err("Usage: atticus absorb <git-url|path> --id <id> [--mode adopt|link|ignore]");
+    return 2;
+  }
+  if (o.mode && !["adopt", "link", "ignore"].includes(o.mode)) {
+    io.err(`--mode is adopt, link or ignore, not ${o.mode}.`);
+    return 2;
+  }
+  try {
+    const r = await absorb(root, url, {
+      id: o.id,
+      ...o.mode ? { mode: o.mode } : {},
+      ...o.ref ? { ref: o.ref } : {},
+      ...o.dryRun ? { dryRun: true } : {}
+    });
+    if (o.json) {
+      io.out(JSON.stringify({
+        id: r.id,
+        format: r.format,
+        entry: r.entry,
+        summary: r.summary,
+        items: r.items.map(({ artifact, ...i }) => ({
+          ...i,
+          ...artifact ? { artifact: artifact.path } : {}
+        })),
+        proposal: r.proposal,
+        files: r.files,
+        problems: r.problems,
+        ms: r.ms
+      }, null, 2));
+      return r.problems.length ? 1 : 0;
+    }
+    const s = r.summary;
+    io.out(`Absorbed ${url} as ${r.id} (${r.format}): ${plural(s.items, "item")}, ${s.byAction.adopt} adopt, ${s.byAction.link} link, ${s.byAction.ignore} ignore.`);
+    for (const i of r.items)
+      io.out(`  ${i.action.padEnd(6)} ${i.kind.padEnd(22)} ${i.path}${i.line ? `:${i.line}` : ""}  ${i.reason}`);
+    io.out(`Translated ${s.translated} of ${s.translatable} items (${s.translatedPercent}%).`);
+    for (const p of r.problems)
+      io.err(`  ${p}`);
+    if (r.proposal)
+      io.out(`Wrote the proposal to ${r.proposal}/ (${plural(r.files.length, "file")}): PR.md is the pull request description; nothing in the org pack was changed.`);
+    return r.problems.length ? 1 : 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function zeroInstallCommand(root, o, io) {
+  try {
+    const r = await zeroInstallFiles(root, o);
+    for (const w of r.results.filter((x) => x.action !== "unchanged"))
+      io.out(`  ${w.action}: ${w.path}`);
+    const problems = await checkZeroInstall(root, r.files.map((f) => ({ path: f.path, content: f.content })));
+    for (const p of problems)
+      io.err(`${p.file} points at ${p.missing}, which doesn't exist.`);
+    if (o.check)
+      io.out(r.upToDate ? "The assistant files are up to date." : "The assistant files are out of date.");
+    else
+      io.out(`Wrote the assistant files (${plural(r.files.length, "file")}); commit them for zero-install use.`);
+    return problems.length || o.check && !r.upToDate ? 1 : 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+export {
+  absorbAcceptCommand,
+  absorbCommand,
+  absorbRefreshCommand,
+  adoptCommand,
+  initCommand,
+  reposDiscoverCommand,
+  sourcesRefreshCommand,
+  unadoptCommand,
+  zeroInstallCommand
+};