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

package/dist/chunk-GWSWS264.js

@@ -0,0 +1,130 @@
+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 {
+  metarepoToolBox
+} from "./chunk-YVCOQ5TZ.js";
+import {
+  CONTEXT_TOOLS
+} from "./chunk-XNRPCI23.js";
+import {
+  TOOL_LIMITS,
+  ToolSession,
+  readToolCalls,
+  recordToolCalls
+} from "./chunk-BKFGGJKA.js";
+import "./chunk-JMOLB347.js";
+import "./chunk-MMB2OHUY.js";
+import "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/context-commands.js
+var box = (root) => metarepoToolBox(root);
+async function runFor(root, name, input, io) {
+  try {
+    io.out(await box(root).call(name, input));
+    return 0;
+  } catch (e) {
+    io.err(e.message);
+    return e.name === "ToolError" ? 2 : 1;
+  }
+}
+function contextShow(root, id, io) {
+  return runFor(root, "show", { id }, io);
+}
+function contextWalk(root, id, o, io) {
+  return runFor(root, "walk", {
+    id,
+    ...o.hops ? { hops: o.hops } : {},
+    ...o.kinds?.length ? { kinds: o.kinds } : {},
+    ...o.limit ? { limit: o.limit } : {}
+  }, io);
+}
+function contextCode(root, o, io) {
+  return runFor(root, "show_code", {
+    ...o.id ? { id: o.id } : {},
+    ...o.repo ? { repo: o.repo } : {},
+    ...o.path ? { path: o.path } : {},
+    ...o.line ? { line: o.line } : {},
+    ...o.around !== void 0 ? { context: o.around } : {}
+  }, io);
+}
+function contextGrep(root, pattern, o, io) {
+  return runFor(root, "grep", {
+    pattern,
+    ...o.regex ? { regex: true } : {},
+    ...o.ignoreCase ? { ignoreCase: true } : {},
+    ...o.repo ? { repo: o.repo } : {},
+    ...o.paths ? { paths: o.paths } : {},
+    ...o.limit ? { limit: o.limit } : {}
+  }, io);
+}
+function contextFiles(root, glob, o, io) {
+  return runFor(root, "files", { glob, ...o.repo ? { repo: o.repo } : {}, ...o.limit ? { limit: o.limit } : {} }, io);
+}
+function contextOutline(root, repo, path, io) {
+  return runFor(root, "outline", { repo, path }, io);
+}
+function contextSimilar(root, id, o, io) {
+  return runFor(root, "similar", { id, ...o.kinds?.length ? { kinds: o.kinds } : {}, ...o.limit ? { limit: o.limit } : {} }, io);
+}
+function contextTools(o, io) {
+  if (o.json) {
+    io.out(JSON.stringify({ tools: CONTEXT_TOOLS, limits: TOOL_LIMITS }, null, 2));
+    return 0;
+  }
+  for (const t of CONTEXT_TOOLS)
+    io.out(`${t.name}: ${t.description}`);
+  io.out(`At most ${TOOL_LIMITS.rounds} rounds of tool calls in a run, ${TOOL_LIMITS.tokens} tokens from tools in all, ${TOOL_LIMITS.perCall} from one call.`);
+  return 0;
+}
+async function contextCall(root, name, o, io) {
+  let input = {};
+  if (o.input !== void 0) {
+    try {
+      const v = JSON.parse(o.input);
+      if (typeof v !== "object" || v === null || Array.isArray(v))
+        throw new Error("not an object");
+      input = v;
+    } catch {
+      io.err(`--input is the tool's input as a JSON object, for example --input '{"id":"forge-ledger"}'.`);
+      return 2;
+    }
+  }
+  const existing = o.run ? await readToolCalls(root, o.run) : void 0;
+  if (o.run && !existing) {
+    io.err(`There is no run ${o.run}. atticus runs lists them.`);
+    return 2;
+  }
+  const session = new ToolSession(metarepoToolBox(root, existing?.tools?.calls), {}, existing?.tools);
+  const before = session.calls.length;
+  const call = await session.run(o.round ?? 1, { name, input });
+  if (o.run)
+    await recordToolCalls(root, o.run, (t) => ({
+      offered: CONTEXT_TOOLS.map((d) => d.name),
+      calls: [...t?.calls ?? [], ...session.calls.slice(before)],
+      ...session.stopped ? { stopped: session.stopped } : {}
+    }));
+  if (o.json)
+    io.out(JSON.stringify({
+      output: call.output,
+      tokens: call.tokens,
+      ...call.error ? { error: true } : {},
+      ...session.stopped ? { stopped: session.stopped } : {}
+    }, null, 2));
+  else
+    io.out(call.output);
+  return 0;
+}
+export {
+  contextCall,
+  contextCode,
+  contextFiles,
+  contextGrep,
+  contextOutline,
+  contextShow,
+  contextSimilar,
+  contextTools,
+  contextWalk
+};

package/dist/chunk-H4VJO3M2.js

@@ -0,0 +1,229 @@
+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 {
+  HttpError,
+  badRequest,
+  notFound
+} from "./chunk-ZTNS3L5Z.js";
+import {
+  readCorrections
+} from "./chunk-ASKDCMW5.js";
+import {
+  applyCorrections,
+  correctedFact,
+  correctionFor,
+  repairFormSlips
+} from "./chunk-XPWSNKF3.js";
+import {
+  FACT_FIXED_FIELDS,
+  FactCorrection,
+  api_exports,
+  correctionLine,
+  factsDirOf,
+  factsRelOf,
+  listQuestions,
+  parseAuditFile,
+  parseFactsLines,
+  sampleConfirmed
+} from "./chunk-JMOLB347.js";
+
+// packages/cli/dist/ui-api-facts.js
+import { appendFile, mkdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+var REPO = /^[a-z0-9][a-z0-9._-]{0,99}$/i;
+var fixed = new Set(FACT_FIXED_FIELDS);
+function factLabel(f) {
+  switch (f.kind) {
+    case "entry":
+      return `${f.method ? `${f.method} ` : ""}${f.path}`;
+    case "call":
+      return `${f.method ? `${f.method} ` : ""}${f.path}${f.to ? ` \u2192 ${f.to}` : ""}`;
+    case "store":
+      return `${f.name} (${f.op})`;
+    case "field":
+      return `${f.name}${f.type ? `: ${f.type}` : ""}`;
+    case "deploy":
+      return `${f.platform}${f.resourceName ? ` ${f.resourceName}` : ""}`;
+    case "config":
+      return `${f.key}${f.value !== void 0 ? ` = ${f.value}` : ""}`;
+    // ADR 0124 addendum A-framework: what the repo or the module is built on.
+    case "framework":
+      return `${f.name}${f.version ? ` ${f.version}` : ""}`;
+    case "flow":
+      return f.name;
+    // ADR 0163: a term of the organisation's, with the role a note gave it.
+    case "term":
+      return `${f.term} ${f.value} (${f.role})`;
+  }
+}
+function claimOf(f) {
+  const out = {};
+  for (const [k, v] of Object.entries(f))
+    if (!fixed.has(k) && typeof v === "string")
+      out[k] = v;
+  out.value = f.cite.value;
+  return out;
+}
+var spot = (c) => ({
+  file: c.file,
+  line: c.line,
+  value: c.value,
+  ...c.quote ? { quote: c.quote } : {}
+});
+async function readFacts(root, repo) {
+  const file = `${factsRelOf(root)}/${repo}.jsonl`;
+  const text = await readFile(join(factsDirOf(root), `${repo}.jsonl`), "utf8").catch(() => void 0);
+  if (text === void 0)
+    return { file, present: false, facts: [], bad: [] };
+  const read = parseFactsLines(text);
+  const p = repairFormSlips(read.facts, read.bad);
+  return {
+    file,
+    present: true,
+    facts: p.facts,
+    bad: [
+      ...p.slips.map((x) => ({
+        file,
+        message: `slip of form fixed as read (a note; atticus verify ${repo} writes the fix into the facts file): ${x.message}`
+      })),
+      ...p.bad.map((b) => ({
+        file,
+        message: `line ${b.line} isn't a fact: ${b.issues.map((i) => i.message).join("; ")}`
+      }))
+    ]
+  };
+}
+async function repoFactsView(root, repo) {
+  const f = await readFacts(root, repo);
+  const cFile = `${factsRelOf(root)}/${repo}.corrections.jsonl`;
+  const c = await readCorrections(root, repo);
+  const problems = [
+    ...f.bad,
+    ...c.bad.map((b) => ({
+      file: cFile,
+      message: `line ${b.line} isn't a correction: ${b.message}`
+    }))
+  ];
+  const auditText = await readFile(join(factsDirOf(root), `${repo}.audit.yaml`), "utf8").catch(() => void 0);
+  const audit = auditText === void 0 ? void 0 : parseAuditFile(auditText);
+  const sampled = sampleConfirmed(audit?.ok ? audit.file : void 0, f.facts);
+  if (audit && !audit.ok)
+    problems.push({
+      file: `${factsRelOf(root)}/${repo}.audit.yaml`,
+      message: `isn't an audit file: ${audit.issues[0] ?? "invalid"}`
+    });
+  const facts = f.facts.map((x) => {
+    const corr = correctionFor(x, c.corrections);
+    return {
+      id: x.id,
+      kind: x.kind,
+      label: factLabel(x),
+      claim: claimOf(x),
+      cite: spot(x.cite),
+      ...x.kind === "flow" ? {
+        steps: [
+          ...x.steps.map((s) => ({ ...spot(s.cite), what: s.what })),
+          ...x.errors.map((e) => ({ ...spot(e.cite), what: `${e.when} \u2192 ${e.then}` }))
+        ]
+      } : {},
+      verified: x.verified === "line" && sampled.has(x.id) ? "sample" : x.verified,
+      by: x.by,
+      ...corr ? { correction: corr } : {}
+    };
+  });
+  const stale = applyCorrections(f.facts, c.corrections).stale.filter((s) => s.why === "none").map((s) => s.correction.fact);
+  const questions = await listQuestions(root, { repo, state: "open" }).then((l) => l.questions.map((q) => ({ id: q.id, question: q.question, evidence: q.evidence })), () => []);
+  return {
+    repo,
+    file: f.file,
+    present: f.present,
+    ...f.facts[0] ? { commit: f.facts[0].commit } : {},
+    facts,
+    corrections: { file: cFile, count: c.corrections.length, stale: [...new Set(stale)].sort() },
+    questions,
+    verify: `atticus verify ${repo}`,
+    problems
+  };
+}
+var repoOf = (v) => {
+  if (!REPO.test(v))
+    throw badRequest(`${JSON.stringify(v)} isn't a repo name.`);
+  return v;
+};
+function uiFactsRoutes(r, ctx, deps = {}) {
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  return r.add("GET", "/api/facts/{repo}", async ({ params }) => ({
+    status: 200,
+    body: await repoFactsView(ctx.root, repoOf(params.repo))
+  })).add("GET", "/api/facts/{repo}/preview", async ({ params, query }) => {
+    const repo = repoOf(params.repo);
+    const fact = query.get("fact") || void 0;
+    const { verifyWritePreview } = await import("./chunk-RWMSJP7H.js");
+    const v = await verifyWritePreview(ctx.root, repo, fact ? { fact } : {});
+    if (!v)
+      throw notFound(`There are no facts for ${repo} at ${factsRelOf(ctx.root)}/${repo}.jsonl.`);
+    return { status: 200, body: v };
+  }).add("POST", "/api/facts/{repo}/corrections", async ({ params, body }) => {
+    const repo = repoOf(params.repo);
+    const b = api_exports.FactCorrectionRequest.safeParse(body ?? {});
+    if (!b.success)
+      throw badRequest("Say which fact and what is wrong: { fact, action, set, line, reason }.", {
+        errors: b.error.issues.map((i) => ({ path: i.path.join("."), message: i.message }))
+      });
+    const f = await readFacts(ctx.root, repo);
+    if (!f.present)
+      throw notFound(`There are no facts for ${repo} at ${f.file}.`);
+    const fact = f.facts.find((x) => x.id === b.data.fact);
+    if (!fact)
+      throw notFound(`${f.file} has no fact ${b.data.fact}.`);
+    const was = claimOf(fact);
+    const set = Object.fromEntries(Object.entries(b.data.set ?? {}).map(([k, v]) => [k, v.trim()]).filter(([k, v]) => was[k] !== v));
+    const line = b.data.line !== void 0 && b.data.line !== fact.cite.line ? b.data.line : void 0;
+    const c = FactCorrection.safeParse({
+      schemaVersion: 1,
+      fact: fact.id,
+      target: {
+        kind: fact.kind,
+        file: fact.cite.file,
+        line: fact.cite.line,
+        value: fact.cite.value
+      },
+      action: b.data.action,
+      ...b.data.action === "edit" && Object.keys(set).length ? { set } : {},
+      ...b.data.action === "edit" && line !== void 0 ? { line } : {},
+      ...b.data.reason ? { reason: b.data.reason } : {},
+      by: ctx.user,
+      at: now().toISOString()
+    });
+    if (!c.success)
+      throw new HttpError(422, "Atticus can't record that", c.error.issues.map((i) => i.message).join("; "));
+    if (c.data.action === "edit") {
+      const fixedFact = correctedFact(fact, c.data);
+      if (typeof fixedFact === "string")
+        throw new HttpError(422, "That isn't a fact", `The corrected ${fact.kind} isn't one: ${fixedFact}.`);
+    }
+    const rel = `${factsRelOf(ctx.root)}/${repo}.corrections.jsonl`;
+    const written = correctionLine(c.data);
+    await mkdir(factsDirOf(ctx.root), { recursive: true });
+    await appendFile(join(factsDirOf(ctx.root), `${repo}.corrections.jsonl`), `${written}
+`, "utf8");
+    ctx.events.publish({ type: "file.changed", path: rel });
+    const result = {
+      correction: c.data,
+      file: rel,
+      commit: `git add ${rel} && git commit -m "${repo}: a person's correction of ${fact.id}"`,
+      verify: `atticus verify ${repo}`,
+      line: written
+    };
+    return { status: 200, body: result };
+  });
+}
+
+export {
+  factLabel,
+  claimOf,
+  uiFactsRoutes
+};