@maycombhq/atticus 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/chunk-M4H2UG4R.js

@@ -0,0 +1,218 @@
+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 {
+  catalogRecords
+} from "./chunk-FY3QIRTL.js";
+import "./chunk-HSZMPH5T.js";
+import "./chunk-D2WSW4GU.js";
+import "./chunk-4KNOJC6J.js";
+import "./chunk-4SLBCEPD.js";
+import {
+  knowledgeGaps
+} from "./chunk-64AADMTW.js";
+import "./chunk-JYMIB5XY.js";
+import "./chunk-CPK7QSBG.js";
+import "./chunk-YO2PKTXT.js";
+import "./chunk-TWQRPM76.js";
+import {
+  gitUser
+} from "./chunk-XOL3GFW2.js";
+import "./chunk-QHJJMZLX.js";
+import "./chunk-7AB6OWTV.js";
+import {
+  Finding,
+  QuestionError,
+  answerQuestion,
+  catalogDirOf,
+  changesDirOf,
+  listQuestions,
+  loadOrgPack,
+  orgPackDirOf,
+  orgPackRelOf,
+  parseRecord,
+  questionsRelOf,
+  recordPath,
+  require_dist,
+  serializeRecord
+} from "./chunk-PAINMSID.js";
+import {
+  writeFileAtomic
+} from "./chunk-ODMBPDDV.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/owner-questions.js
+var import_yaml = __toESM(require_dist(), 1);
+import { mkdir, readFile } from "node:fs/promises";
+import { dirname, join, relative } from "node:path";
+import { parseArgs } from "node:util";
+var OwnerQuestionError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+  }
+};
+var rel = (root, p) => relative(root, p).split("\\").join("/");
+var stamp = (d) => d.toISOString().replace(/\.\d{3}Z$/, "Z");
+async function gaps(root, now) {
+  const records = await catalogRecords(root);
+  if (records.length === 0)
+    return void 0;
+  const orgPack = await loadOrgPack(orgPackDirOf(root));
+  return knowledgeGaps({ records, orgPack, now: stamp(now) });
+}
+var fileOf = (root, id) => join(catalogDirOf(root), "curated", ...recordPath({ kind: "OwnerQuestion", id }).split("/"));
+function itemOf(root, g) {
+  const q = g.question;
+  return {
+    id: q.id,
+    system: q.system,
+    owner: q.owner,
+    question: q.question,
+    neededFact: q.neededFact,
+    channel: q.channel,
+    state: q.questionState,
+    ...q.answer ? { answer: q.answer } : {},
+    ...g.routeTo ? { routeTo: g.routeTo } : {},
+    ...g.fill?.length ? { fill: g.fill } : {},
+    records: g.records,
+    file: rel(root, fileOf(root, q.id))
+  };
+}
+async function gapSummary(root, f) {
+  const path = join(changesDirOf(root), f.change, "review", f.gate, String(f.round), `${f.id}.yaml`);
+  const text = await readFile(path, "utf8").catch(() => void 0);
+  const r = text === void 0 ? void 0 : Finding.safeParse((0, import_yaml.parse)(text));
+  return r?.success ? r.data.summary : `Knowledge gap ${f.id} at the ${f.gate} gate.`;
+}
+async function askedGapItems(root) {
+  const { questions } = await listQuestions(root).catch(() => ({ questions: [] }));
+  const out = [];
+  for (const q of questions) {
+    if (!q.finding || q.state === "retired")
+      continue;
+    out.push({
+      id: q.id,
+      system: q.finding.change,
+      owner: q.askedOf ?? "its owner",
+      question: q.question,
+      neededFact: await gapSummary(root, q.finding),
+      channel: "Atticus",
+      state: q.state === "answered" ? "answered" : "sent",
+      ...q.answer?.text ? { answer: q.answer.text } : {},
+      records: [],
+      file: `${questionsRelOf(root)}/${q.id}.yaml`,
+      finding: { change: q.finding.change, gate: q.finding.gate, id: q.finding.id }
+    });
+  }
+  return out.sort((a, b) => Number(a.state === "answered") - Number(b.state === "answered"));
+}
+async function ownerQuestions(root, o = {}) {
+  const found = await gaps(root, o.now ?? /* @__PURE__ */ new Date());
+  const asked = await askedGapItems(root);
+  if (!found && !asked.length)
+    return { empty: true, open: 0, questions: [] };
+  const questions = [...asked, ...(found ?? []).map((g) => itemOf(root, g))];
+  return {
+    empty: false,
+    open: questions.filter((q) => q.state !== "answered").length,
+    questions
+  };
+}
+async function answerOwnerQuestion(root, id, answer, o) {
+  const words = answer.trim();
+  if (!words)
+    throw new OwnerQuestionError("The answer is empty: say what the owner said.", "invalid");
+  if (!o.by.trim())
+    throw new OwnerQuestionError("Say who answered (--by).", "invalid");
+  const now = o.now ?? /* @__PURE__ */ new Date();
+  const onFile = (await askedGapItems(root)).find((x) => x.id === id);
+  if (onFile) {
+    try {
+      await answerQuestion(root, id, { text: words, by: o.by.trim(), at: stamp(now) });
+    } catch (e) {
+      if (e instanceof QuestionError)
+        throw new OwnerQuestionError(e.message, "invalid");
+      throw e;
+    }
+    const question2 = (await askedGapItems(root)).find((x) => x.id === id);
+    return { file: question2.file, question: question2 };
+  }
+  const found = await gaps(root, now) ?? [];
+  const g = found.find((x) => x.question.id === id);
+  if (!g)
+    throw new OwnerQuestionError(`There is no owner question ${id} now: atticus questions lists the open ones.`, "not-found");
+  const p = parseRecord({
+    ...g.question,
+    confidence: "asserted",
+    questionState: "answered",
+    answer: words,
+    evidence: [
+      { source: "manual", by: o.by.trim(), scannedAt: stamp(now) },
+      ...g.question.evidence
+    ]
+  });
+  if (!p.ok)
+    throw new OwnerQuestionError(`The answer can't be recorded: ${JSON.stringify(p.issues)}`, "invalid");
+  const full = fileOf(root, id);
+  await mkdir(dirname(full), { recursive: true });
+  await writeFileAtomic(full, serializeRecord(p.record));
+  const question = itemOf(root, {
+    ...g,
+    question: { ...g.question, questionState: "answered", answer: words }
+  });
+  return { file: question.file, question };
+}
+async function ownerQuestionCommand(root, argv, io, deps = {}) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    strict: false,
+    options: {
+      root: { type: "string" },
+      text: { type: "string" },
+      by: { type: "string" },
+      json: { type: "boolean" }
+    }
+  });
+  const id = positionals[2];
+  const text = typeof values.text === "string" ? values.text : void 0;
+  if (!id || text === void 0) {
+    io.err('Usage: atticus questions owner <id> --text "..." [--by who] [--json]');
+    return 2;
+  }
+  const by = typeof values.by === "string" && values.by.trim() || (await gitUser(root)).handle;
+  try {
+    const r = await answerOwnerQuestion(root, id, text, {
+      by,
+      ...deps.now ? { now: deps.now } : {}
+    });
+    if (values.json === true)
+      io.out(JSON.stringify(r, null, 2));
+    else if (r.question.finding)
+      io.out(`Wrote ${r.file}: ${by}'s answer to ${id}. Knowledge gap ${r.question.finding.id} is closed at the ${r.question.finding.gate} gate; the next draft of ${r.question.finding.change} reads the answer.`);
+    else {
+      io.out(`Wrote ${r.file}: ${by}'s answer to ${id}. Every scan keeps it.`);
+      io.out(r.question.fill?.length ? `The gap closes once the fact is in the catalog: write it in ${r.question.fill.map((f) => `${orgPackRelOf(root)}/${f.file}: ${f.field}`).join("; ")}.` : `The gap closes once the fact is in the catalog: ${r.question.neededFact}.`);
+      io.out("Then propose it for review (the app's Propose for review, or commit it in a pull request).");
+    }
+    return 0;
+  } catch (e) {
+    if (e instanceof OwnerQuestionError) {
+      io.err(e.message);
+      return e.code === "invalid" ? 2 : 1;
+    }
+    throw e;
+  }
+}
+export {
+  OwnerQuestionError,
+  answerOwnerQuestion,
+  ownerQuestionCommand,
+  ownerQuestions
+};

package/dist/{chunk-6BVONWJ7.js → chunk-M6D2U3YM.js}

@@ -5,11 +5,11 @@ var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
 var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
 import {
   runOpenSpecRaw
-} from "./chunk-4AK7IBVP.js";
+} from "./chunk-D2WSW4GU.js";
 import {
   changesDirOf
-} from "./chunk-S2A7YC3Q.js";
-import "./chunk-D3PO4DOZ.js";
+} from "./chunk-PAINMSID.js";
+import "./chunk-ODMBPDDV.js";
 import "./chunk-TV45EUGM.js";
 
 // packages/cli/dist/openspec-run-commands.js