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

package/dist/chunk-JUZ75OG4.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-7LCQ7JAM.js";
+import {
+  SCAN_REVIEW_OUTPUT
+} from "./chunk-XKJRPVJO.js";
+import {
+  completeHandUpLens,
+  handUpLensTask
+} from "./chunk-EI4KQYJ3.js";
+import {
+  completeCriticLens,
+  yamlAnswerProblems
+} from "./chunk-HGQZTUAC.js";
+import {
+  completeFeatureNaming
+} from "./chunk-R3VFLYZZ.js";
+import {
+  completeTemplatesDraft
+} from "./chunk-JRPQX2EK.js";
+import {
+  completeGlossaryScan
+} from "./chunk-J27QGXO4.js";
+import {
+  DRAFT_OUTPUT,
+  STORY_PROSE_OUTPUT,
+  TEMPLATE_PROSE_CHANGE,
+  TEMPLATE_PROSE_OUTPUT,
+  checkStageDraft,
+  formatDraftProblems,
+  parseDraft,
+  stageOfOutput
+} from "./chunk-EV4TEFOD.js";
+import {
+  lensAnswerProblem,
+  lensRunOf
+} from "./chunk-T6ESD5KM.js";
+import {
+  ORG_FLOW,
+  createOpenSpec,
+  setDefaultSchema,
+  writeOrgFlowSchema
+} from "./chunk-L7I5PKGD.js";
+import {
+  GLOSSARY_CHANGE,
+  GLOSSARY_OUTPUT
+} from "./chunk-IILZ7J3L.js";
+import {
+  KNOWLEDGE_SCAN_OUTPUT,
+  NAMING_CHANGE,
+  NAMING_OUTPUT,
+  checkScanAnswer,
+  readSnapshot
+} from "./chunk-TEBBD4XH.js";
+import {
+  GitError,
+  createWorkspace,
+  intellijProjectPath,
+  loadRepos,
+  vscodeWorkspacePath
+} from "./chunk-XZJE6WIT.js";
+import {
+  HandoffRuntime
+} from "./chunk-BKFGGJKA.js";
+import {
+  runsDirOf
+} from "./chunk-JMOLB347.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
+};