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

package/dist/chunk-AA6YULYB.js

@@ -0,0 +1,376 @@
+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 {
+  judgingRuntime
+} from "./chunk-BWZ77RQT.js";
+import {
+  table
+} from "./chunk-VOGCSYOI.js";
+import {
+  draftChange,
+  draftTemplates,
+  metarepoAdapters,
+  planStories,
+  readStoryEval,
+  snowDraft,
+  storyBar,
+  submitRequests,
+  syncWorkItems
+} from "./chunk-CKSITVS4.js";
+import {
+  runtimeForCli
+} from "./chunk-CNUKCS2T.js";
+import {
+  changesRelOf,
+  proposalsRelOf
+} from "./chunk-S2A7YC3Q.js";
+
+// packages/cli/dist/plan-commands.js
+import { resolve } from "node:path";
+var KNOWN = /* @__PURE__ */ new Set([
+  "PlannerError",
+  "ChangeError",
+  "ChangeFileError",
+  "AdapterError",
+  "RuntimeConfigError",
+  "StepFileError"
+]);
+function fail(io, e) {
+  if (e instanceof Error && KNOWN.has(e.name)) {
+    io.err(e.message);
+    for (const p of e.problems ?? [])
+      io.err(`  ${p}`);
+    return e.code === "invalid" ? 2 : 1;
+  }
+  throw e;
+}
+var plural = (n, w) => `${n} ${n === 1 ? w : w.endsWith("y") && !/[aeiou]y$/.test(w) ? `${w.slice(0, -1)}ies` : `${w}s`}`;
+var iso = (d) => d.toISOString().replace(/\.\d{3}Z$/, "Z");
+async function runtimeOf(root, mode, deps) {
+  if (deps.runtime)
+    return deps.runtime;
+  return (await runtimeForCli(root, mode ? { mode } : {})).runtime;
+}
+async function planStories2(root, changeId, o, io, deps = {}) {
+  if (!changeId) {
+    io.err("Usage: atticus plan stories <change> [--force] [--resume <run>] [--mode <mode>] [--json]");
+    return 2;
+  }
+  try {
+    const runtime = await runtimeOf(root, o.mode, deps);
+    const r = await planStories(root, changeId, {
+      runtime,
+      ...deps.now ? { now: deps.now() } : {},
+      ...o.force ? { force: true } : {},
+      ...o.resume ? { resume: o.resume } : {},
+      ...o.draft ? { draft: true } : {}
+    });
+    if (o.json) {
+      io.out(JSON.stringify({
+        change: r.change,
+        state: r.state,
+        stories: r.skeleton.stories.map((s) => ({
+          id: s.id,
+          title: r.prose.get(s.id)?.title,
+          source: s.source,
+          systems: s.systems,
+          repos: s.repos,
+          tests: s.tests,
+          dependsOn: s.dependsOn,
+          openQuestions: s.openQuestions.map((q) => q.text)
+        })),
+        notPlanned: r.skeleton.notPlanned,
+        tasks: r.skeleton.tasks,
+        fallback: r.fallback,
+        discarded: r.discarded,
+        files: r.files,
+        ...r.waiting ? { waiting: r.waiting } : {}
+      }, null, 2));
+      return r.state === "written" ? 0 : 1;
+    }
+    if (r.state === "waiting") {
+      io.out(`Handed the story prose to your assistant (run ${r.waiting.runId}). When it is done, run: atticus plan stories ${changeId} --resume ${r.waiting.runId}`);
+      return 1;
+    }
+    if (o.draft)
+      io.out("These are draft stories from the design as it stands; plan again once the design is approved.");
+    io.out(`Planned ${plural(r.skeleton.stories.length, "story")} and ${plural(r.skeleton.tasks.length, "task")} for ${r.change} in ${plural(r.skeleton.repos.length, "repo")}.`);
+    for (const line of table(["STORY", "TITLE", "REPOS", "TESTS"], r.skeleton.stories.map((s) => [
+      s.id,
+      r.prose.get(s.id)?.title ?? "",
+      s.repos.join(", "),
+      s.tests.join(", ")
+    ])))
+      io.out(line);
+    for (const n of r.skeleton.notPlanned)
+      io.out(`Not planned: ${n.what}: ${n.why}.`);
+    if (r.fallback.length)
+      io.out(`No AI prose for ${r.fallback.join(", ")}: a person words ${r.fallback.length === 1 ? "it" : "them"}.`);
+    for (const d of r.discarded)
+      io.out(`Discarded AI output${d.id ? ` for ${d.id}` : ""}: ${d.reason}.`);
+    io.out(`Next: atticus plan snow ${changeId}, then atticus plan bar ${changeId}.`);
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function snowDraft2(root, changeId, o, io) {
+  if (!changeId) {
+    io.err("Usage: atticus plan snow <change> [--force] [--json]");
+    return 2;
+  }
+  try {
+    const r = await snowDraft(root, changeId, o.force ? { force: true } : {});
+    if (o.json) {
+      io.out(JSON.stringify(r.drafts.map((d) => ({
+        template: d.need.template.id,
+        record: d.need.record,
+        why: d.need.why,
+        fields: d.fields,
+        assumed: d.assumed,
+        missing: d.missing
+      })), null, 2));
+      return r.drafts.some((d) => d.missing.length) ? 1 : 0;
+    }
+    if (r.drafts.length === 0) {
+      io.out(`${changeId} needs no service-desk request.`);
+      return 0;
+    }
+    io.out(`Wrote ${plural(r.drafts.length, "service-desk draft")} to ${changesRelOf(root)}/${changeId}/snow.md.`);
+    for (const d of r.drafts) {
+      io.out(`  ${d.need.template.requestType} for ${d.need.record} (${d.need.template.leadTimeDays} days): ${d.need.why}`);
+      for (const m of d.missing)
+        io.out(`    To fill: ${m}`);
+      for (const a of d.assumed)
+        io.out(`    Assumed: ${a}`);
+    }
+    return r.drafts.some((d) => d.missing.length) ? 1 : 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function storyBarCommand(root, changeId, o, io, deps = {}) {
+  if (!changeId) {
+    io.err("Usage: atticus plan bar <change> [--eval <expected stories.yaml>] [--json]");
+    return 2;
+  }
+  try {
+    const ev = o.eval ? await readStoryEval(resolve(root, o.eval)) : void 0;
+    const runtime = await judgingRuntime(root, deps.runtime);
+    const r = await storyBar(root, changeId, {
+      ...ev ? { eval: ev } : {},
+      ...runtime ? { runtime } : {}
+    });
+    if (o.json) {
+      io.out(JSON.stringify(r, null, 2));
+      return r.met ? 0 : 1;
+    }
+    const pct = Math.round(r.ready.rate * 100);
+    io.out(`${r.ready.passed} of ${r.ready.total} stories are ready (${pct}%, the bar is ${Math.round(r.ready.min * 100)}%); ${r.gaps.filter((g) => g.covered).length} of ${r.gaps.length} gaps covered; ${plural(r.invented.length, "invented name")}.`);
+    for (const s of r.stories.filter((x) => !x.ready))
+      io.out(`  ${s.id}: ${s.problems.join("; ")}`);
+    for (const s of r.stories.filter((x) => x.wording.length))
+      io.out(`  ${s.id} (wording): ${s.wording.join("; ")}`);
+    for (const g of r.gaps.filter((x) => !x.covered))
+      io.out(`  Gap not covered: ${g.id}: ${g.what}`);
+    for (const x of [...r.outline, ...r.regressions])
+      io.out(`  ${x}`);
+    const open = r.dor.filter((d) => d.notJudged?.length);
+    if (open.length)
+      io.out(`  For a person: no one has judged which of the bar's checks ${open.length === 1 ? "this definition-of-ready item asks" : "these definition-of-ready items ask"} for (no model was asked), so ${open.length === 1 ? "it isn't" : "they aren't"} checked: ${open.map((d) => `"${d.item}"`).join(", ")}.`);
+    io.out(r.met ? "The story bar is met." : "The story bar is not met.");
+    return r.met ? 0 : 1;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+function printSync(r, what, io) {
+  const todo = r.writes.filter((w) => w.action === "create" || w.action === "update");
+  if (r.dryRun) {
+    io.out(`Dry run: ${plural(todo.length, `${what} write`)} for ${r.change}. Nothing was sent.`);
+    for (const line of table(["ACTION", "KEY", "TITLE"], r.writes.filter((w) => w.action !== "unchanged").map((w) => [w.action, w.key, w.title])))
+      io.out(line);
+    if (todo.length)
+      io.out("Approve every write listed with --approve (you approve as your Git user).");
+    return 0;
+  }
+  io.out(`Sent ${plural(r.done.length, `${what} write`)} for ${r.change}.`);
+  for (const d of r.done)
+    io.out(d.id.startsWith("manual:") ? `  ${d.action} ${d.key}: a step for a person (${d.id.slice(7)}); see atticus todo.` : `  ${d.action} ${d.key}: ${d.id}`);
+  for (const s of r.skipped)
+    io.out(`  Skipped ${s.key}: ${s.reason}.`);
+  for (const f of r.failed)
+    io.err(`  Failed ${f.key}: ${f.reason}.`);
+  return r.failed.length ? 1 : 0;
+}
+var approver = (by, now) => by ? (w) => ({ by: by.replace(/^@/, ""), at: iso(now()), ref: w.key }) : void 0;
+async function adoSync(root, changeId, o, io, deps = {}) {
+  if (!changeId) {
+    io.err("Usage: atticus ado sync <change> [--dry-run] [--approve <you>] [--epic <id>] [--json]");
+    return 2;
+  }
+  try {
+    const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+    const workTracker = deps.workTracker ?? (await metarepoAdapters(root, {
+      change: changeId,
+      onFallback: (e) => io.err(`The work tracker can't be reached (${e.code}); writing steps for a person instead.`)
+    })).workTracker;
+    if (!workTracker) {
+      io.err("runtime.yaml configures no work tracker. Set adapters.workTracker (type manual works with no integration).");
+      return 1;
+    }
+    const approve = approver(o.approve, now);
+    const r = await syncWorkItems(root, changeId, {
+      workTracker,
+      dryRun: o.dryRun || !approve,
+      ...approve ? { approve } : {},
+      ...o.epic ? { epic: o.epic } : {},
+      now: iso(now())
+    });
+    if (o.json) {
+      io.out(JSON.stringify(r, null, 2));
+      return r.failed.length ? 1 : 0;
+    }
+    return printSync(r, "work-item", io);
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function snowSubmit(root, changeId, o, io, deps = {}) {
+  if (!changeId) {
+    io.err("Usage: atticus plan submit <change> [--dry-run] [--approve <you>] [--json]");
+    return 2;
+  }
+  try {
+    const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+    const serviceDesk = deps.serviceDesk ?? (await metarepoAdapters(root, { change: changeId })).serviceDesk;
+    if (!serviceDesk) {
+      io.err("runtime.yaml configures no service desk. Set adapters.serviceDesk (type manual works with no integration).");
+      return 1;
+    }
+    const approve = approver(o.approve, now);
+    const r = await submitRequests(root, changeId, {
+      serviceDesk,
+      dryRun: o.dryRun || !approve,
+      ...approve ? { approve } : {},
+      now: iso(now())
+    });
+    if (o.json) {
+      io.out(JSON.stringify(r, null, 2));
+      return r.failed.length ? 1 : 0;
+    }
+    return printSync(r, "service-desk", io);
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function templatesDraft(root, o, io, deps = {}) {
+  try {
+    const runtime = o.noAi ? void 0 : await runtimeOf(root, o.mode, deps);
+    const r = await draftTemplates(root, {
+      ...runtime ? { runtime } : {},
+      ...deps.now ? { now: deps.now() } : {}
+    });
+    return reportTemplates(root, r, o, io);
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function completeTemplatesDraft(root, run, io, deps = {}) {
+  try {
+    const r = await draftTemplates(root, {
+      finished: run,
+      ...deps.now ? { now: deps.now() } : {}
+    });
+    return reportTemplates(root, r, {}, io);
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+function reportTemplates(root, r, o, io) {
+  {
+    if (o.json) {
+      io.out(JSON.stringify({
+        templates: r.templates.map((t) => ({
+          id: t.id,
+          existing: t.existing,
+          template: t.template,
+          notes: t.notes,
+          problems: t.problems
+        })),
+        procedures: r.procedures.map((p) => p.id),
+        workItems: r.workItems,
+        triage: r.triage,
+        files: r.files,
+        problems: r.problems
+      }, null, 2));
+      return 0;
+    }
+    io.out(`Read ${plural(r.sources.howTos.length, "how-to source")}, ${plural(r.sources.tickets.length, "ticket export")} and ${plural(r.sources.workItems.length, "work-item export")}.`);
+    for (const t of r.templates)
+      io.out(`  ${t.id}: ${t.existing === "matches" ? "the org pack's template agrees" : t.existing === "differs" ? "the org pack's template disagrees (see triage)" : "new draft"}`);
+    for (const t of r.triage)
+      io.out(`  Needs a decision: ${t.summary}`);
+    for (const p of r.problems)
+      io.err(`  ${p}`);
+    io.out(`Wrote the proposal to ${proposalsRelOf(root)}/templates/ (${plural(r.files.length, "file")}); read SUMMARY.md, then copy what you accept into org-pack/ in a pull request.`);
+    return 0;
+  }
+}
+async function changeDraft(root, changeId, o, io, deps = {}) {
+  if (!changeId) {
+    io.err("Usage: atticus change draft <change> [--attempts n] [--force] [--resume <run>] [--mode <mode>] [--json]");
+    return 2;
+  }
+  try {
+    const runtime = await runtimeOf(root, o.mode, deps);
+    const r = await draftChange(root, changeId, {
+      runtime,
+      ...deps.now ? { now: deps.now() } : {},
+      ...o.attempts ? { attempts: o.attempts } : {},
+      ...o.force ? { force: true } : {},
+      ...o.resume ? { resume: o.resume } : {}
+    });
+    if (o.json) {
+      io.out(JSON.stringify(r, null, 2));
+      return r.state === "written" ? 0 : 1;
+    }
+    if (r.state === "waiting") {
+      if (r.problems.length) {
+        io.out("The last draft went back to your assistant to fix:");
+        for (const p of r.problems)
+          io.out(`  ${p}`);
+      }
+      io.out(`Handed the draft to your assistant (run ${r.waiting.runId}), with the brief and ${plural(r.map.length, "catalog record")} it is about. When it is done, run: atticus change draft ${changeId} --resume ${r.waiting.runId}`);
+      return 1;
+    }
+    if (r.state === "failed") {
+      io.err(`The draft still had problems after ${plural(r.attempts, "attempt")}; nothing was written:`);
+      for (const p of r.problems)
+        io.err(`  ${p}`);
+      return 1;
+    }
+    const dir = `${changesRelOf(root)}/${r.change}`;
+    io.out(`Drafted ${r.files.join(", ")} in ${dir} (${plural(r.attempts, "attempt")}), from the brief and ${plural(r.map.length, "catalog record")}. Review and edit them; they are yours now.`);
+    for (const d of r.discarded)
+      io.out(`Left out ${d}: a draft writes only the change's design files.`);
+    io.out(`Next: atticus critic ${r.change}, then atticus plan stories ${r.change}.`);
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+
+export {
+  planStories2 as planStories,
+  snowDraft2 as snowDraft,
+  storyBarCommand,
+  adoSync,
+  snowSubmit,
+  templatesDraft,
+  completeTemplatesDraft,
+  changeDraft
+};

package/dist/chunk-ABWHYWNI.js

@@ -0,0 +1,101 @@
+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 {
+  scanInputs
+} from "./chunk-23W7VWKR.js";
+import {
+  documentFormat,
+  readDocument
+} from "./chunk-7EKXJZ2Y.js";
+import {
+  inputsDirOf
+} from "./chunk-S2A7YC3Q.js";
+
+// packages/cli/dist/inputs-knowledge.js
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+var INPUTS_SOURCE_ID = "inputs";
+var INPUTS_SOURCE = {
+  id: INPUTS_SOURCE_ID,
+  type: "markdown-folder",
+  location: "inputs/",
+  spaces: []
+};
+var NOT_TEXT = {
+  image: "a picture: a person reads it, since AI steps take text only",
+  openapi: "an OpenAPI spec: intake reads it into the catalog (atticus intake)",
+  swagger: "a Swagger spec: intake reads it into the catalog (atticus intake)",
+  asyncapi: "an AsyncAPI spec: intake reads it into the catalog (atticus intake)",
+  diagram: "a diagram: intake reads it (atticus intake)",
+  payload: "a payload sample: intake reads its schema (atticus intake)"
+};
+function markdownOf(read) {
+  const out = [`# ${read.text.title}`, ""];
+  for (const s of read.text.sections) {
+    const page = s.page ? ` (page ${s.page})` : "";
+    if (s.heading)
+      out.push(`${"#".repeat(Math.min(6, Math.max(2, s.level + 1)))} ${s.heading}${page}`, "");
+    else if (page)
+      out.push(`(page ${s.page})`, "");
+    if (s.text.trim())
+      out.push(s.text.trim(), "");
+  }
+  for (const t of read.text.tables ?? []) {
+    t.forEach((row, i) => {
+      out.push(`| ${row.map((c) => c.replace(/\|/g, "\\|")).join(" | ")} |`);
+      if (i === 0)
+        out.push(`|${row.map(() => " --- |").join("")}`);
+    });
+    out.push("");
+  }
+  for (const n of read.notes)
+    out.push(`> ${n}`, "");
+  return out.join("\n");
+}
+async function inputsPages(root, op) {
+  const dir = inputsDirOf(root);
+  const intake = await scanInputs({
+    root,
+    orgPack: op,
+    inputsDir: dir,
+    scannedAt: "1970-01-01T00:00:00Z"
+  });
+  const byId = new Map(intake.documents.filter((d) => d.id).map((d) => [d.id, d]));
+  const pages = [];
+  const skipped = [];
+  const skip = (path, reason) => skipped.push({ source: INPUTS_SOURCE_ID, path, reason });
+  for (const d of [...intake.documents].sort((a, b) => a.path < b.path ? -1 : 1)) {
+    if (d.status === "duplicate") {
+      skip(d.path, `the same file as ${d.duplicateOf ?? "another one in inputs/"}`);
+      continue;
+    }
+    if (d.supersededBy) {
+      const newer = byId.get(d.supersededBy)?.path ?? d.supersededBy;
+      skip(d.path, `an older version: ${newer} is newer, and is the one read`);
+      continue;
+    }
+    const why = NOT_TEXT[d.classification];
+    if (why) {
+      skip(d.path, why);
+      continue;
+    }
+    const rel = d.path.replace(/^inputs\//, "");
+    const bytes = new Uint8Array(await readFile(join(dir, ...rel.split("/"))));
+    if (!documentFormat(rel, bytes.slice(0, 4096))) {
+      skip(d.path, "not a document Atticus reads as text");
+      continue;
+    }
+    const content = /\.(md|markdown)$/i.test(rel) ? new TextDecoder().decode(bytes) : markdownOf(readDocument(rel, bytes));
+    pages.push({ pagePath: rel, path: d.path, content });
+  }
+  return { pages, skipped };
+}
+
+export {
+  INPUTS_SOURCE_ID,
+  INPUTS_SOURCE,
+  inputsPages
+};