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

package/dist/chunk-N3E56YPN.js

@@ -0,0 +1,344 @@
+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 {
+  storeSummaryLines
+} from "./chunk-Z7SG32ZY.js";
+import {
+  SCAN_REVIEW_OUTPUT
+} from "./chunk-DPC5Y5DL.js";
+import {
+  completeCriticLens,
+  yamlAnswerProblems
+} from "./chunk-RZUZ4RJJ.js";
+import {
+  completeFeatureNaming
+} from "./chunk-L3BX5ZIB.js";
+import {
+  completeTemplatesDraft
+} from "./chunk-OW7D2PJL.js";
+import {
+  completeGlossaryScan
+} from "./chunk-ZJSP24X4.js";
+import {
+  completeHandUpLens,
+  handUpLensTask
+} from "./chunk-RCU3MPY2.js";
+import {
+  DRAFT_OUTPUT,
+  STORY_PROSE_OUTPUT,
+  TEMPLATE_PROSE_CHANGE,
+  TEMPLATE_PROSE_OUTPUT,
+  checkStageDraft,
+  formatDraftProblems,
+  parseDraft,
+  stageOfOutput
+} from "./chunk-VPTTCYOC.js";
+import {
+  lensAnswerProblem,
+  lensRunOf
+} from "./chunk-7UFQZXZA.js";
+import {
+  ORG_FLOW,
+  createOpenSpec,
+  setDefaultSchema,
+  writeOrgFlowSchema
+} from "./chunk-4AK7IBVP.js";
+import {
+  GLOSSARY_CHANGE,
+  GLOSSARY_OUTPUT
+} from "./chunk-OLWFG75W.js";
+import {
+  KNOWLEDGE_SCAN_OUTPUT,
+  NAMING_CHANGE,
+  NAMING_OUTPUT,
+  checkScanAnswer,
+  readSnapshot
+} from "./chunk-L24C55VN.js";
+import {
+  GitError,
+  createWorkspace,
+  intellijProjectPath,
+  loadRepos,
+  vscodeWorkspacePath
+} from "./chunk-KJPMEAI4.js";
+import {
+  HandoffRuntime
+} from "./chunk-CNUKCS2T.js";
+import {
+  runsDirOf
+} from "./chunk-S2A7YC3Q.js";
+
+// packages/cli/dist/workspace-commands.js
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+function pick(all, wanted, io) {
+  if (!wanted || wanted.length === 0)
+    return all;
+  const byId = new Map(all.map((r) => [r.id, r]));
+  const unknown = wanted.filter((w) => !byId.has(w));
+  if (unknown.length > 0) {
+    io.err(`Not in any repos.manifest.yaml: ${unknown.join(", ")}`);
+    return void 0;
+  }
+  return wanted.map((w) => byId.get(w));
+}
+async function workspaceSync(root, repoIds, io, o = {}) {
+  const all = await loadRepos(root);
+  if (all.length === 0) {
+    io.err("No repos found. Add org-pack/profiles/<platform>/repos.manifest.yaml first.");
+    return 1;
+  }
+  const repos = pick(all, repoIds, io);
+  if (!repos)
+    return 2;
+  const results = await createWorkspace(root).sync(repos, o.from ? { from: o.from } : {});
+  for (const r of results) {
+    const sha = r.sha ? ` ${r.sha.slice(0, 12)}` : "";
+    const why = r.from ? `copied from your clone at ${r.from}` : r.reason;
+    const line = `${r.id}: ${r.action}${sha}${why ? ` (${why})` : ""}`;
+    if (r.action === "failed")
+      io.err(line);
+    else
+      io.out(line);
+    const named = repos.find((x) => x.id === r.id)?.defaultBranch;
+    if (r.remoteDefault && named && r.remoteDefault !== named)
+      io.err(`${r.id}: the manifest says ${named}, the remote's default is ${r.remoteDefault}. The catalog is read from ${named}; if ${r.remoteDefault} is the one to read, set defaultBranch: ${r.remoteDefault} in the manifest (or on Set up \u203A Repos).`);
+  }
+  return results.some((r) => r.action === "failed") ? 1 : 0;
+}
+async function workspaceOpen(root, change, repoIds, io) {
+  if (!repoIds || repoIds.length === 0) {
+    io.err("Say which repos the change touches: --repos <id>,<id>");
+    return 2;
+  }
+  const repos = pick(await loadRepos(root), repoIds, io);
+  if (!repos)
+    return 2;
+  let c;
+  try {
+    c = await createWorkspace(root).openChange(change, repos);
+  } catch (e) {
+    if (!(e instanceof GitError))
+      throw e;
+    io.err(`Git couldn't open the worktrees: ${(e.stderr || e.message).trim().split("\n")[0]}`);
+    io.err(/origin\//.test(e.message + e.stderr) ? "A base clone has no origin branch to start from: run atticus workspace sync, then try again." : "Run atticus doctor, and atticus workspace sync, then try again.");
+    return 1;
+  }
+  for (const r of c.repos)
+    io.out(`${r.id}: ${r.branch} at ${r.worktree}`);
+  io.out(`VS Code: ${vscodeWorkspacePath(root, change)}`);
+  io.out(`IntelliJ: open the folder ${intellijProjectPath(root, change)}`);
+  return 0;
+}
+async function workspacePrune(root, change, opts, io) {
+  const r = await createWorkspace(root).prune(change, opts);
+  for (const id of r.removed)
+    io.out(`${id}: removed`);
+  for (const k of r.kept)
+    io.out(`${k.id}: kept (${k.reason})`);
+  return 0;
+}
+async function openspecSetup(root, io) {
+  const os = createOpenSpec({ root });
+  const v = await os.assertSupported();
+  await os.init();
+  await writeOrgFlowSchema(root);
+  await setDefaultSchema(root, ORG_FLOW);
+  io.out(`OpenSpec ${v} set up with the ${ORG_FLOW} schema in ${root}`);
+  return 0;
+}
+async function openspecCheck(root, io) {
+  const os = createOpenSpec({ root });
+  const v = await os.assertSupported();
+  const report = await os.validate();
+  for (const item of report.items) {
+    for (const issue of item.issues.filter((i) => i.level !== "INFO")) {
+      io.err(`${item.type} ${item.id}: ${issue.level}: ${issue.message}`);
+    }
+  }
+  const t = report.summary.totals;
+  io.out(`OpenSpec ${v}: ${t.items} checked, ${t.passed} passed, ${t.failed} failed`);
+  const stores = await storeSummaryLines(root);
+  for (const l of stores.out)
+    io.out(l);
+  for (const l of stores.err)
+    io.err(l);
+  return t.failed > 0 ? 1 : 0;
+}
+function completionOf(request) {
+  if (handUpLensTask(request.outputPath))
+    return "hand-up";
+  if (lensRunOf(request))
+    return "critic-lens";
+  if (request.change === GLOSSARY_CHANGE && request.outputPath === GLOSSARY_OUTPUT)
+    return "glossary";
+  if (request.outputIn === "run" && request.outputPath === STORY_PROSE_OUTPUT)
+    return "story-prose";
+  if (request.outputIn === "run" && request.outputPath === DRAFT_OUTPUT)
+    return "change-draft";
+  if (request.outputIn === "run" && request.outputPath === SCAN_REVIEW_OUTPUT)
+    return "scan-review";
+  if (request.change === NAMING_CHANGE && request.outputPath === NAMING_OUTPUT)
+    return "feature-names";
+  if (request.change === TEMPLATE_PROSE_CHANGE && request.outputPath === TEMPLATE_PROSE_OUTPUT)
+    return "templates";
+  if (request.outputIn === "run")
+    return "step-answer";
+  return "artifact";
+}
+async function handoffDone(root, runId, io, deps = {}) {
+  const os = createOpenSpec({ root });
+  const before = await readRunJson(root, runId);
+  const checks = before ? before.state === "failed" ? before.attempt + 1 : before.attempt : 1;
+  let handedAsIs;
+  const selfChecked = async (file, request) => {
+    const stage = stageOfOutput(request.outputPath);
+    if (!request.selfCheck || !stage)
+      return [];
+    const problems = await checkStageDraft(root, request.change, stage, await readFile(file, "utf8").catch(() => "")).catch((e) => [
+      { rule: "stage.check", target: stage, message: e.message, blocking: true }
+    ]);
+    if (!problems.length)
+      return [];
+    if (checks >= request.selfCheck.limit) {
+      handedAsIs = checks;
+      return [];
+    }
+    return [formatDraftProblems(problems)];
+  };
+  const scanChecked = async (file, request) => {
+    if (request.change !== "knowledge-scan" || request.outputPath !== KNOWLEDGE_SCAN_OUTPUT)
+      return [];
+    const problems = checkScanAnswer(await scanSnapshots(root, request), await readFile(file, "utf8").catch(() => ""));
+    if (!problems.length)
+      return [];
+    if (checks >= SCAN_CHECKS) {
+      handedAsIs = checks;
+      return [];
+    }
+    return [
+      `The answer fails ${problems.length === 1 ? "a check" : `${problems.length} checks`} the knowledge scan makes; fix each in ${request.outputPath} (or drop the item):`,
+      ...problems.map((p) => `- ${p}`)
+    ];
+  };
+  const rt = new HandoffRuntime({
+    root,
+    validate: async (_file, request) => {
+      if (completionOf(request) === "change-draft") {
+        const files = parseDraft(await readFile(_file, "utf8").catch(() => ""));
+        return files.has("proposal.md") ? [] : ['The draft has no "=== proposal.md" file; start each file with a line "=== <path>".'];
+      }
+      if (completionOf(request) === "step-answer") {
+        if (!/\.ya?ml$/.test(request.outputPath))
+          return (await readFile(_file, "utf8").catch(() => "")).trim() ? [] : [`${request.outputPath} is empty`];
+        const yaml = await yamlAnswerProblems(_file, request);
+        if (yaml.length)
+          return yaml;
+        const scan = await scanChecked(_file, request);
+        return scan.length ? scan : selfChecked(_file, request);
+      }
+      if (completionOf(request) === "hand-up") {
+        const why = lensAnswerProblem(await readFile(_file, "utf8").catch(() => ""));
+        return why ? [`${request.outputPath}: ${why}`] : [];
+      }
+      if (completionOf(request) !== "artifact")
+        return yamlAnswerProblems(_file, request);
+      const report = await os.validate({ item: request.change, type: "change" });
+      return report.items.flatMap((i) => i.issues.filter((x) => x.level === "ERROR").map((x) => x.message));
+    }
+  });
+  const run = await rt.done(runId, deps.model ? { model: deps.model } : {});
+  if (run.state === "validated") {
+    const kind = completionOf(run.request);
+    const now = deps.now?.();
+    if (kind === "hand-up") {
+      const r = await completeHandUpLens(root, run, {
+        ...now ? { now: now.toISOString().replace(/\.\d{3}Z$/, "Z") } : {}
+      });
+      const n = r.review?.findings.filter((f) => f.finding.artifact.startsWith(`tasks/${r.task}/`)).length;
+      io.out(r.lens.state === "ran" ? `The complete lens on task ${r.task} of ${r.change} raised ${n ?? 0} finding${n === 1 ? "" : "s"} (review/hand-up/${r.review?.round ?? "-"}).` : `The complete lens on task ${r.task} was ${r.lens.state}: ${r.lens.reason ?? ""}`);
+      for (const d of r.lens.discarded)
+        io.err(`Discarded: ${d.reason}`);
+      return r.lens.state === "ran" ? 0 : 1;
+    }
+    if (kind === "critic-lens")
+      return completeCriticLens(root, run, io, {
+        ...now ? { now: now.toISOString().replace(/\.\d{3}Z$/, "Z") } : {}
+      });
+    if (kind === "glossary")
+      return completeGlossaryScan(root, run, io, now ? { now } : {});
+    if (kind === "story-prose") {
+      io.out(`The story prose for ${run.request.change} is valid. Next: atticus plan stories ${run.request.change} --resume ${runId}`);
+      return 0;
+    }
+    if (kind === "scan-review") {
+      const repo = run.request.change.replace(/^review-/, "");
+      io.out(`The review of ${repo} is in. Next: atticus scan review ${repo} --resume ${runId}`);
+      return 0;
+    }
+    if (kind === "change-draft") {
+      io.out(`The draft for ${run.request.change} is in. Next: atticus change draft ${run.request.change} --resume ${runId}`);
+      return 0;
+    }
+    if (kind === "step-answer") {
+      if (handedAsIs)
+        io.out(run.request.change === "knowledge-scan" ? `${run.request.outputPath} still has problems, and is handed in as it is after ${handedAsIs} checks: the knowledge scan keeps what passes and hands the rest back with its next prompt.` : `${run.request.outputPath} still has problems, and is handed in as it is after ${handedAsIs} checks: the stage hands its problems back with the next draft.`);
+      io.out(`The answer for ${run.request.change} is in. Run the step again with --resume ${runId}: it checks the answer and writes the result.`);
+      return 0;
+    }
+    if (kind === "feature-names")
+      return completeFeatureNaming(root, run, io, now ? { now } : {});
+    if (kind === "templates")
+      return completeTemplatesDraft(root, run, io, deps);
+    io.out(`${run.request.outputPath} for ${run.request.change} is valid`);
+    return 0;
+  }
+  for (const e of run.errors)
+    io.err(e);
+  io.err(`${run.request.outputPath} needs fixing; run atticus handoff done ${runId} again when it's fixed`);
+  return 1;
+}
+var SCAN_CHECKS = 3;
+async function scanSnapshots(root, request) {
+  const sent = new Set(request.pack.manifest.sources.filter((s) => s.id.startsWith("page-")).map((s) => s.origin));
+  const out = [];
+  for (const source of [...new Set([...sent].map((o) => o.split("/")[0]))].sort()) {
+    const s = await readSnapshot(root, source).catch(() => void 0);
+    if (!s)
+      continue;
+    out.push({ ...s, pages: s.pages.filter((p) => sent.has(`${p.source}/${p.pagePath}`)) });
+  }
+  return out;
+}
+async function readRunJson(root, runId) {
+  const { readdir } = await import("node:fs/promises");
+  const dir = runsDirOf(root);
+  for (const change of await readdir(dir).catch(() => [])) {
+    const text = await readFile(join(dir, change, runId, "run.json"), "utf8").catch(() => void 0);
+    if (text === void 0)
+      continue;
+    try {
+      const r = JSON.parse(text);
+      return {
+        state: typeof r.state === "string" ? r.state : "",
+        attempt: typeof r.attempt === "number" ? r.attempt : 1
+      };
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+
+export {
+  workspaceSync,
+  workspaceOpen,
+  workspacePrune,
+  openspecSetup,
+  openspecCheck,
+  completionOf,
+  handoffDone
+};

package/dist/chunk-NHFQMOVK.js

@@ -0,0 +1,180 @@
+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 {
+  diffCatalogs,
+  readCatalog
+} from "./chunk-OLWFG75W.js";
+import "./chunk-L24C55VN.js";
+import "./chunk-PAMPPUR6.js";
+import "./chunk-23W7VWKR.js";
+import "./chunk-7EKXJZ2Y.js";
+import "./chunk-MC3H7736.js";
+import {
+  baseClonePath,
+  branchSlug,
+  checkoutState,
+  gitUser,
+  loadRepos,
+  remoteDefaultBranch
+} from "./chunk-KJPMEAI4.js";
+import "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import {
+  ManifestEditError,
+  REPO_DESCRIPTION_MAX,
+  RepoDescription,
+  RepoManifest,
+  catalogDirOf,
+  orgPackDirOf,
+  require_dist,
+  setManifestDescription
+} from "./chunk-S2A7YC3Q.js";
+import {
+  writeFileAtomic
+} from "./chunk-D3PO4DOZ.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/repo-branches.js
+var import_yaml = __toESM(require_dist(), 1);
+var import_yaml2 = __toESM(require_dist(), 1);
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+async function branchScans(root) {
+  const dir = join(catalogDirOf(root), "branches");
+  const out = [];
+  for (const d of (await readdir(dir).catch(() => [])).sort()) {
+    const text = await readFile(join(dir, d, "branch.yaml"), "utf8").catch(() => void 0);
+    if (!text)
+      continue;
+    const m = (0, import_yaml2.parse)(text);
+    if (typeof m.branch === "string" && typeof m.scannedAt === "string" && Array.isArray(m.repos))
+      out.push({ branch: m.branch, scannedAt: m.scannedAt, repos: m.repos });
+  }
+  return out;
+}
+async function repoBranches(root) {
+  const scans = await branchScans(root);
+  const repos = [];
+  for (const r of await loadRepos(root)) {
+    if (r.archived)
+      continue;
+    const base = baseClonePath(root, r.id);
+    const remoteDefault = await remoteDefaultBranch(base);
+    const commit = await checkoutState(base).then((s) => s.commit, () => void 0);
+    repos.push({
+      id: r.id,
+      platform: r.platform,
+      url: r.url,
+      type: r.type,
+      owner: r.owner,
+      // What it is, in a person's words, or a draft nobody has confirmed (ADR 0128).
+      ...r.description ? { description: r.description } : {},
+      defaultBranch: r.defaultBranch,
+      ...remoteDefault ? { remoteDefault } : {},
+      branches: r.branches,
+      ...commit ? { commit } : {},
+      scans: scans.flatMap((s) => s.repos.filter((x) => x.id === r.id).map((x) => ({ branch: s.branch, scannedAt: s.scannedAt, commit: x.commit })))
+    });
+  }
+  return { repos };
+}
+var key = (r) => `${r.kind}/${r.id}`;
+async function compareBranch(root, branch) {
+  const scan = (await branchScans(root)).find((s) => s.branch === branch);
+  if (!scan)
+    return void 0;
+  const ids = new Set(scan.repos.map((r) => r.id));
+  const ofRepos = (records) => records.filter((r) => r.evidence.some((e) => e.repo && ids.has(e.repo)));
+  const cat = catalogDirOf(root);
+  const before = await readCatalog(join(cat, "generated"), { cacheRoot: root });
+  const after = await readCatalog(join(cat, "branches", branchSlug(branch), "generated"), {
+    cacheRoot: root
+  });
+  const d = diffCatalogs(ofRepos(before.records), ofRepos(after.records));
+  return {
+    branch,
+    scannedAt: scan.scannedAt,
+    repos: scan.repos,
+    added: d.added.map(key),
+    removed: d.removed.map(key),
+    changed: d.changed.map((c) => ({ record: key(c), fields: c.fields }))
+  };
+}
+var RepoEditError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+};
+async function editRepoBranches(root, repoId, set) {
+  const repo = (await loadRepos(root)).find((r) => r.id === repoId);
+  if (!repo)
+    throw new RepoEditError("not-found", `There is no repo ${repoId} in any manifest.`);
+  const rel = `org-pack/profiles/${repo.platform}/repos.manifest.yaml`;
+  const file = join(orgPackDirOf(root), "profiles", repo.platform, "repos.manifest.yaml");
+  const doc = (0, import_yaml.parseDocument)(await readFile(file, "utf8"));
+  const list = doc.get("repos");
+  const item = (0, import_yaml.isSeq)(list) ? list.items.find((x) => (0, import_yaml.isMap)(x) && x.get("id") === repoId) : void 0;
+  if (!(0, import_yaml.isMap)(item))
+    throw new RepoEditError("not-found", `${rel} doesn't list ${repoId}.`);
+  const branches = set.branches?.map((b) => b.trim()).filter(Boolean);
+  const def = set.defaultBranch?.trim() || repo.defaultBranch;
+  if (branches?.includes(def))
+    throw new RepoEditError("invalid", `${def} is the default branch: its catalog is the baseline, so it isn't one of the branches scanned beside it.`);
+  if (set.defaultBranch?.trim())
+    item.set("defaultBranch", set.defaultBranch.trim());
+  if (branches) {
+    if (branches.length)
+      item.set("branches", doc.createNode([...new Set(branches)]));
+    else
+      item.delete("branches");
+  }
+  const check = RepoManifest.safeParse(doc.toJS());
+  if (!check.success)
+    throw new RepoEditError("invalid", check.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; "));
+  await writeFileAtomic(file, doc.toString({ flowCollectionPadding: true }));
+  return rel;
+}
+async function editRepoDescription(root, repoId, set, o = {}) {
+  const repo = (await loadRepos(root)).find((r) => r.id === repoId);
+  if (!repo)
+    throw new RepoEditError("not-found", `There is no repo ${repoId} in any manifest.`);
+  const now = o.now ?? /* @__PURE__ */ new Date();
+  let next;
+  if (!set.reject) {
+    const text = set.text?.trim() || (set.accept ? repo.description?.text : void 0);
+    if (!text)
+      throw new RepoEditError("invalid", set.accept ? `${repoId} has no drafted description to confirm. Write one instead.` : `Say what ${repoId} is, in one line.`);
+    if (text.length > REPO_DESCRIPTION_MAX)
+      throw new RepoEditError("invalid", `That is ${text.length} characters; a description is one line, up to ${REPO_DESCRIPTION_MAX}.`);
+    const by = o.by ?? await gitUser(root).then((u) => u.handle, () => "someone");
+    next = RepoDescription.parse({
+      text,
+      trust: "verified",
+      by,
+      at: now.toISOString().replace(/\.\d{3}Z$/, "Z")
+    });
+  } else if (!repo.description)
+    throw new RepoEditError("invalid", `${repoId} has no description to drop.`);
+  try {
+    const f = await setManifestDescription(root, repoId, next);
+    return { file: f.rel, ...next ? { description: next } : {} };
+  } catch (e) {
+    if (e instanceof ManifestEditError)
+      throw new RepoEditError(e.code === "not-found" ? "not-found" : "invalid", e.message);
+    throw e;
+  }
+}
+export {
+  RepoEditError,
+  compareBranch,
+  editRepoBranches,
+  editRepoDescription,
+  repoBranches
+};

package/dist/chunk-NQU6KNQF.js

@@ -0,0 +1,27 @@
+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 {
+  diagramLibrary,
+  diagramRender,
+  loadCatalog
+} from "./chunk-2UIQBDJO.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-KJPMEAI4.js";
+import "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+export {
+  diagramLibrary,
+  diagramRender,
+  loadCatalog
+};