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

package/dist/chunk-ZDPAS56H.js

@@ -0,0 +1,76 @@
+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/top-commands.js
+var TOP_WORDS = [
+  "init",
+  "map",
+  "verify",
+  "join",
+  "change",
+  "critic",
+  "stories",
+  "task",
+  "questions",
+  "knowledge",
+  "next",
+  "ui"
+];
+var TOP = new Set(TOP_WORDS);
+var isLegacy = (first) => !!first && !TOP.has(first) && first !== "legacy" && first !== "help";
+var TOP_HELP = `  atticus init <folder> --platform <p>  Start your team's metarepo (atticus adopt <path> uses Atticus inside one repo)
+  atticus map <repo>                    Your assistant reads a repo into facts, each citing its file and line (/atticus-map does it in one session)
+  atticus verify <repo> [--write]       Check the facts against the code; --write puts them in the catalog and renders the map
+  atticus join [--json]                 Follow flows from repo to repo through the calls the facts join; writes specs/estate.yaml
+  atticus change new "<title>"          Start a change; atticus help change lists its stages and the rest
+  atticus critic <change>               Review a change: rule checks, then four questions (is it true, complete, safe, can it ship)
+  atticus stories <change>              The stories stage: stories with acceptance criteria and tasks, from the design
+  atticus task <change> <task>          Run one task with your assistant: a plan, a draft or a pull request
+  atticus questions                     What Atticus needs a person to answer, and who can answer it
+  atticus knowledge scan                Read your wikis into patterns, standards, processes and decisions; atticus help knowledge lists the rest
+  atticus next                          The next step to take, its command and its slash command
+  atticus ui [--open]                   Open the app on this machine
+
+  atticus help <command>                What one command takes (atticus explain <command> says it in plain words)
+  atticus legacy                        Every other command (scan, plan, release, estate and more); each still runs by its own name
+  atticus help --all                    Every command, grouped by area`;
+function topHelp(versionLine) {
+  return [
+    versionLine,
+    "",
+    "Map a multi-repo estate from its code, then take each change from idea to code, with a person approving every gate.",
+    "",
+    TOP_HELP,
+    "",
+    "Every command also takes --root <dir> (the metarepo) and --by <handle> (who is acting)."
+  ].join("\n");
+}
+function aliasArgv(argv, positions) {
+  const out = [...argv];
+  let at = [...positions];
+  if (at.length > 1 && out[at[0]] === "legacy") {
+    out.splice(at[0], 1);
+    at = at.slice(1).map((i) => i - 1);
+  }
+  const first = at[0];
+  if (first === void 0)
+    return out;
+  const word = out[first];
+  const second = at[1] === void 0 ? void 0 : out[at[1]];
+  if (word === "join")
+    out.splice(first, 1, "estate", "join");
+  else if (word === "stories")
+    out.splice(first, 1, "plan", "stories");
+  else if (word === "task" && second !== "run" && second !== "context")
+    out.splice(first + 1, 0, "run");
+  return out;
+}
+
+export {
+  isLegacy,
+  topHelp,
+  aliasArgv
+};

package/dist/chunk-ZMAINWBW.js

@@ -0,0 +1,18 @@
+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 {
+  ME_FILE,
+  readMe,
+  writeMe
+} from "./chunk-JBTK5OP2.js";
+import "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+export {
+  ME_FILE,
+  readMe,
+  writeMe
+};

package/dist/chunk-ZMFPW66A.js

@@ -0,0 +1,22 @@
+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 {
+  NoRoomError,
+  ceilingOf,
+  reExecForMemory,
+  roomGuard,
+  streamFacts
+} from "./chunk-EPTBZ3GP.js";
+import "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+export {
+  NoRoomError,
+  ceilingOf,
+  reExecForMemory,
+  roomGuard,
+  streamFacts
+};

package/dist/chunk-ZNCEKR4J.js

@@ -0,0 +1,296 @@
+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 {
+  readCatalog
+} from "./chunk-27NKUS3X.js";
+import {
+  TriageError,
+  buildTriage,
+  classify,
+  scanInputs
+} from "./chunk-23W7VWKR.js";
+import {
+  readDrawio,
+  reconcile
+} from "./chunk-7EKXJZ2Y.js";
+import {
+  inputsDirOf,
+  loadOrgPack,
+  orgPackDirOf,
+  recordPath,
+  serializeRecord
+} from "./chunk-S2A7YC3Q.js";
+
+// packages/cli/dist/intake-commands.js
+import { createHash } from "node:crypto";
+import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { userInfo } from "node:os";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
+var inboxRelOf = (root) => relative(root, join(inputsDirOf(root), "inbox")).split(sep).join("/");
+async function filesUnder(dir) {
+  const out = [];
+  async function walk(d) {
+    let entries;
+    try {
+      entries = await readdir(d, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries.sort((a, b) => a.name < b.name ? -1 : 1)) {
+      const full = join(d, e.name);
+      if (e.isDirectory())
+        await walk(full);
+      else if (e.isFile())
+        out.push(full);
+    }
+  }
+  await walk(dir);
+  return out;
+}
+var sha256 = (b) => createHash("sha256").update(b).digest("hex");
+var rel = (root, p) => relative(root, p).split(sep).join("/");
+async function addToInbox(root, files) {
+  const INBOX = inboxRelOf(root);
+  const inbox = join(root, ...INBOX.split("/"));
+  const known = /* @__PURE__ */ new Map();
+  for (const f of await filesUnder(inputsDirOf(root)))
+    known.set(sha256(new Uint8Array(await readFile(f))), rel(root, f));
+  const added = [];
+  const refused = [];
+  for (const { name, bytes } of files) {
+    if (!name || /[\\/]/.test(name) || name === "." || name === "..") {
+      refused.push({ name, why: "give a file name without a folder in it" });
+      continue;
+    }
+    if (bytes.length === 0) {
+      refused.push({ name, why: "it is empty" });
+      continue;
+    }
+    const hash = sha256(bytes);
+    const already = known.get(hash);
+    if (already) {
+      refused.push({ name, why: `it is already in inputs as ${already}` });
+      continue;
+    }
+    const dot = name.lastIndexOf(".");
+    const [stem, ext] = dot > 0 ? [name.slice(0, dot), name.slice(dot)] : [name, ""];
+    await mkdir(inbox, { recursive: true });
+    const taken = new Set(await readdir(inbox));
+    let target = name;
+    for (let n = 2; taken.has(target); n++)
+      target = `${stem}-${n}${ext}`;
+    await writeFile(join(inbox, target), bytes);
+    const path = `${INBOX}/${target}`;
+    known.set(hash, path);
+    added.push({ name, path, kind: classify(target, bytes).classification });
+  }
+  return { added, refused };
+}
+async function intakeAdd(root, files, io) {
+  if (files.length === 0) {
+    io.err("Name at least one file to add.");
+    return 2;
+  }
+  let problems = false;
+  let added = 0;
+  let documents = 0;
+  const ALREADY = "it is already in inputs as ";
+  for (const f of files) {
+    const src = resolve(f);
+    let bytes;
+    try {
+      bytes = new Uint8Array(await readFile(src));
+    } catch {
+      io.err(`Can't read ${f}.`);
+      problems = true;
+      continue;
+    }
+    const r = await addToInbox(root, [{ name: basename(src), bytes }]);
+    for (const x of r.refused) {
+      io.err(x.why.startsWith(ALREADY) ? `${f} is already in inputs as ${x.why.slice(ALREADY.length)}; not copied.` : `${f} wasn't copied: ${x.why}.`);
+      problems = true;
+    }
+    for (const a of r.added) {
+      const reading = a.kind === "document" || a.kind === "image" ? ", needs reading" : "";
+      io.out(`Added ${a.path} (${a.kind}${reading}).`);
+      added++;
+      if (a.kind === "document")
+        documents++;
+    }
+  }
+  if (added > 0)
+    io.out("Run atticus intake list to see what Atticus made of them.");
+  if (documents > 0)
+    io.out("To read the documents into knowledge every change can use: atticus sources sync --source inputs, then atticus knowledge scan --source inputs.");
+  return problems ? 1 : 0;
+}
+async function intakeContext(root, io) {
+  const op = await loadOrgPack(join(orgPackDirOf(root)));
+  const catalogDir = join(root, op.sources.layout.catalog);
+  const generated = await readCatalog(join(catalogDir, "generated"), { cacheRoot: root });
+  const curated = await readCatalog(join(catalogDir, "curated"), { cacheRoot: root });
+  for (const p of [...generated.problems, ...curated.problems])
+    io.err(`catalog ${p.file}: ${p.message}`);
+  const inputs = await scanInputs({
+    root,
+    orgPack: op,
+    records: [...generated.records, ...curated.records],
+    inputsDir: inputsDirOf(root)
+  });
+  return { op, records: generated.records, curated: curated.records, inputs };
+}
+var STATUS_WORDS = [
+  ["read", (n) => `${n} read`],
+  ["needs-reading", (n) => `${n} need${n === 1 ? "s" : ""} reading`],
+  ["no-reader", (n) => `${n} with no reader yet`],
+  ["unresolved", (n) => `${n} waiting for a system name`],
+  ["duplicate", (n) => `${n} duplicate${n === 1 ? "" : "s"}`],
+  ["superseded", (n) => `${n} older version${n === 1 ? "" : "s"}`],
+  ["failed", (n) => `${n} failed`]
+];
+function chains(docs) {
+  const byId = new Map(docs.filter((d) => d.id).map((d) => [d.id, d]));
+  const replaced = new Set(docs.flatMap((d) => d.supersededBy ? [d.supersededBy] : []));
+  const out = [];
+  for (const d of docs) {
+    if (!d.supersededBy || d.id && replaced.has(d.id))
+      continue;
+    const chain = [d.path];
+    const seen = /* @__PURE__ */ new Set([d.id]);
+    for (let next = byId.get(d.supersededBy); next && !seen.has(next.id); ) {
+      chain.push(next.path);
+      seen.add(next.id);
+      next = next.supersededBy ? byId.get(next.supersededBy) : void 0;
+    }
+    out.push(chain);
+  }
+  return out;
+}
+async function intakeList(root, io, o) {
+  const { inputs } = await intakeContext(root, io);
+  const { documents, problems } = inputs;
+  if (o.json) {
+    io.out(JSON.stringify({ documents, chains: chains(documents), problems }, null, 2));
+    return problems.length > 0 ? 1 : 0;
+  }
+  if (documents.length === 0) {
+    io.out("Nothing in inputs/ yet: drop files into inputs/inbox/, or run atticus intake add <files>.");
+    return problems.length > 0 ? 1 : 0;
+  }
+  for (const l of table(["PATH", "TYPE", "STATUS", "SYSTEMS"], documents.map((d) => [
+    d.path,
+    d.classification,
+    d.duplicateOf ? `duplicate of ${d.duplicateOf}` : d.status,
+    d.systems.join(", ")
+  ])))
+    io.out(l);
+  const ch = chains(documents);
+  if (ch.length > 0) {
+    io.out("Versions:");
+    for (const c of ch)
+      io.out(`  ${c.join(" \u2192 ")}`);
+  }
+  const counts = STATUS_WORDS.map(([s, words]) => {
+    const n = documents.filter((d) => d.status === s).length;
+    return n > 0 ? words(n) : "";
+  }).filter(Boolean);
+  io.out(`${documents.length} file${documents.length === 1 ? "" : "s"}: ${counts.join(", ")}.`);
+  for (const p of problems)
+    io.out(`  ! ${p.path}: ${p.message}`);
+  return problems.length > 0 ? 1 : 0;
+}
+async function triageOf(root, io) {
+  const { op, records, curated, inputs } = await intakeContext(root, io);
+  if (records.length === 0 && inputs.documents.length > 0)
+    io.err("The catalog is empty: run atticus scan first, or most diagram edges will look unknown.");
+  const profile = op.profiles.find((p) => p.profile)?.profile;
+  const all = [...records, ...curated];
+  const reconcileItems = [];
+  for (const d of inputs.documents.filter((x) => x.classification === "diagram" && x.status === "read" && x.reader?.startsWith("drawio@"))) {
+    const xml = await readFile(join(root, ...d.path.split("/")), "utf8");
+    reconcileItems.push({
+      file: d.path,
+      items: reconcile({
+        diagram: readDrawio(xml, profile?.legend),
+        file: d.path,
+        records: all,
+        systems: profile?.systems ?? [],
+        patterns: op.patterns
+      }).items
+    });
+  }
+  return buildTriage({ records, inputs, decisions: curated, reconcileItems, ai: op.runtime.ai });
+}
+async function triageList(root, io, o) {
+  const { items } = await triageOf(root, io);
+  if (o.json) {
+    io.out(JSON.stringify({ items }, null, 2));
+    return items.length > 0 ? 1 : 0;
+  }
+  if (items.length === 0) {
+    io.out("Nothing to triage.");
+    return 0;
+  }
+  io.out(`${items.length} item${items.length === 1 ? "" : "s"} to decide.`);
+  for (const i of items) {
+    io.out("");
+    io.out(`${i.id} (${i.kind})`);
+    io.out(`  ${i.summary}`);
+    const where = `${i.source.path}${i.source.line ? `:${i.source.line}` : ""}`;
+    io.out(`  at ${where}${i.source.cell ? ` (cell ${i.source.cell})` : ""}`);
+    i.options.forEach((opt, n) => io.out(`  ${n + 1}. ${opt.label}`));
+    if (i.next)
+      io.out(`  \u2192 ${i.next}`);
+  }
+  io.out("");
+  io.out("Decide one with: atticus triage decide <item> <option>");
+  return 1;
+}
+async function triageDecide(root, itemId, option, o, io) {
+  const t = await triageOf(root, io);
+  const item = t.items.find((i) => i.id === itemId);
+  if (!item) {
+    io.err(`There is no open triage item ${itemId}. List them with: atticus triage`);
+    return 1;
+  }
+  if (!Number.isInteger(option) || option < 1 || option > item.options.length) {
+    const n = item.options.length;
+    io.err(`${itemId} has ${n} option${n === 1 ? "" : "s"}; pick 1 to ${n}.`);
+    return 2;
+  }
+  let decision;
+  try {
+    decision = t.decide(itemId, option - 1, {
+      by: o.by ?? userInfo().username,
+      ...o.reason ? { reason: o.reason } : {}
+    });
+  } catch (e) {
+    if (e instanceof TriageError) {
+      io.err(e.message);
+      return 1;
+    }
+    throw e;
+  }
+  const op = await loadOrgPack(join(orgPackDirOf(root)));
+  const relPath = `${op.sources.layout.catalog}/curated/${recordPath(decision)}`;
+  const full = join(root, ...relPath.split("/"));
+  await mkdir(dirname(full), { recursive: true });
+  await writeFile(full, serializeRecord(decision), "utf8");
+  io.out(`Wrote ${relPath}: ${item.options[option - 1].label}. Commit it so everyone's triage uses it.`);
+  return 0;
+}
+
+export {
+  addToInbox,
+  intakeAdd,
+  intakeContext,
+  intakeList,
+  triageList,
+  triageDecide
+};

package/dist/chunk-ZVM6AKKM.js

@@ -0,0 +1,47 @@
+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 {
+  contextToolBox,
+  defaultCodeDir,
+  namesInCode,
+  openIndex,
+  workspaceRepos
+} from "./chunk-T6AIP7H5.js";
+
+// packages/cli/dist/code-tools.js
+var offered = /* @__PURE__ */ new Map();
+function offerCodeDir(repo, dir) {
+  offered.set(repo, dir);
+}
+function codeToolOptions(root) {
+  return {
+    codeDir: (r) => offered.get(r) ?? defaultCodeDir(root, r),
+    repos: () => [.../* @__PURE__ */ new Set([...workspaceRepos(root), ...offered.keys()])].sort(),
+    // Loaded on first use: the readers are large, and most commands never outline a file.
+    outline: async (path, text) => (await import("./chunk-MMOSZPWJ.js")).declarationOutline(path, text)
+  };
+}
+function metarepoToolBox(root, calls) {
+  return contextToolBox(root, () => openIndex(root), {
+    ...codeToolOptions(root),
+    ...calls ? { calls } : {}
+  });
+}
+async function criticCodeSearch(root, names) {
+  const x = await import("./chunk-MMOSZPWJ.js");
+  const r = await namesInCode(root, names, {
+    ...codeToolOptions(root),
+    outlines: (path) => x.syntaxLanguageOf(path) !== void 0
+  });
+  return r.found;
+}
+
+export {
+  offerCodeDir,
+  codeToolOptions,
+  metarepoToolBox,
+  criticCodeSearch
+};