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

package/dist/chunk-TC3KTG33.js

@@ -0,0 +1,221 @@
+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 {
+  badRequest
+} from "./chunk-ZTNS3L5Z.js";
+import {
+  catalogRecords
+} from "./chunk-HR4DVO6X.js";
+import {
+  RecordId,
+  catalogDirOf,
+  changesDirOf,
+  readRepoSpec,
+  require_dist,
+  specRepos,
+  specsDirOf
+} from "./chunk-JMOLB347.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/ui-api-cites.js
+import { readdir, readFile, stat } from "node:fs/promises";
+import { isAbsolute, join, relative, sep } from "node:path";
+var import_yaml = __toESM(require_dist(), 1);
+async function fingerprint(dirs) {
+  let count = 0;
+  let newest = 0;
+  const walk = async (d) => {
+    const entries = await readdir(d, { withFileTypes: true }).catch(() => []);
+    for (const e of entries) {
+      const p = join(d, e.name);
+      if (e.isDirectory())
+        await walk(p);
+      else {
+        count++;
+        const s = await stat(p).catch(() => void 0);
+        if (s && s.mtimeMs > newest)
+          newest = s.mtimeMs;
+      }
+    }
+  };
+  for (const d of dirs)
+    await walk(d);
+  return `${count}:${newest}`;
+}
+async function build(root) {
+  const index = /* @__PURE__ */ new Map();
+  const lineOf = (repo, path, line) => {
+    const files = index.get(repo) ?? /* @__PURE__ */ new Map();
+    index.set(repo, files);
+    const lines = files.get(path) ?? /* @__PURE__ */ new Map();
+    files.set(path, lines);
+    const l = lines.get(line) ?? { line, flows: [], records: [] };
+    lines.set(line, l);
+    return l;
+  };
+  for (const specRepo of await specRepos(root))
+    for (const f of (await readRepoSpec(root, specRepo, { cacheRoot: root })).flows) {
+      const parts = [
+        { step: 0, kind: f.trigger.kind, evidence: f.trigger.evidence },
+        ...f.steps.map((s, i) => ({
+          step: i + 1,
+          kind: s.kind,
+          ...s.confirmedBy ? { confirmedBy: s.confirmedBy } : {},
+          evidence: s.evidence
+        }))
+      ];
+      for (const part of parts)
+        for (const e of part.evidence) {
+          if (!e.path || e.line === void 0)
+            continue;
+          const l = lineOf(e.repo ?? specRepo, e.path, e.line);
+          if (l.flows.some((x) => x.flow === f.id && x.step === part.step))
+            continue;
+          l.flows.push({
+            repo: specRepo,
+            flow: f.id,
+            name: f.name,
+            step: part.step,
+            kind: part.kind,
+            ...part.confirmedBy ? { confirmedBy: part.confirmedBy } : {}
+          });
+        }
+    }
+  for (const r of await catalogRecords(root)) {
+    const name = r.name;
+    for (const e of r.evidence) {
+      if (!e.repo || !e.path || e.line === void 0)
+        continue;
+      const l = lineOf(e.repo, e.path, e.line);
+      if (l.records.some((x) => x.kind === r.kind && x.id === r.id))
+        continue;
+      l.records.push({
+        kind: r.kind,
+        id: r.id,
+        ...typeof name === "string" && name !== r.id ? { name } : {},
+        source: e.source
+      });
+    }
+  }
+  return index;
+}
+var DONE = /* @__PURE__ */ new Set(["released", "archived", "post-release-review"]);
+async function inFlight(root) {
+  const out = /* @__PURE__ */ new Map();
+  const dir = changesDirOf(root);
+  for (const e of await readdir(dir, { withFileTypes: true }).catch(() => [])) {
+    if (!e.isDirectory() || e.name === "archive")
+      continue;
+    const yaml = await readFile(join(dir, e.name, "change.yaml"), "utf8").catch(() => "");
+    const state = (() => {
+      try {
+        return (0, import_yaml.parse)(yaml)?.state;
+      } catch {
+        return void 0;
+      }
+    })();
+    if (!yaml || typeof state === "string" && DONE.has(state))
+      continue;
+    for (const f of await readdir(join(dir, e.name, "target-flows")).catch(() => []))
+      if (f.endsWith(".yaml")) {
+        const flow = f.slice(0, -".yaml".length);
+        out.set(flow, [...out.get(flow) ?? [], e.name]);
+      }
+  }
+  return out;
+}
+async function citeList(root, index, repo, path) {
+  const lines = [...index.get(repo)?.get(path)?.values() ?? []].sort((a, b) => a.line - b.line);
+  const flying = await inFlight(root);
+  const shown = lines.map((l) => ({
+    ...l,
+    flows: [...l.flows].sort((a, b) => a.flow.localeCompare(b.flow) || a.step - b.step).map((f) => flying.get(f.flow)?.length ? { ...f, changes: flying.get(f.flow) } : f)
+  }));
+  return { repo, path, lines: shown };
+}
+function fileInRepo(root, file) {
+  const rel = relative(root, file);
+  if (!rel || rel.startsWith("..") || isAbsolute(rel))
+    return void 0;
+  const parts = rel.split(sep);
+  if (parts[0] !== "workspace")
+    return { path: parts.join("/") };
+  const at = parts[1] === ".worktrees" ? 3 : parts[1] === ".branches" ? 2 : 1;
+  const repo = parts[at];
+  const rest = parts.slice(parts[1] === ".branches" ? 4 : at + 1);
+  if (!repo || !rest.length || !RecordId.safeParse(repo).success)
+    return void 0;
+  return { repo, path: rest.join("/") };
+}
+async function citesCli(root, o, io) {
+  let repo = o.repo;
+  let path = o.path;
+  const index = await build(root);
+  if (o.file) {
+    const at = fileInRepo(root, o.file);
+    if (!at) {
+      io.err(`${o.file} isn't in this metarepo or a repo's checkout in its workspace.`);
+      return 1;
+    }
+    path = at.path;
+    repo = at.repo ?? [...index.keys()].find((r) => index.get(r).has(at.path)) ?? void 0;
+    if (!repo) {
+      if (o.json)
+        io.out(JSON.stringify({ repo: "", path, lines: [] }, null, 2));
+      else
+        io.out(`Nothing in the specs or the catalog cites ${path}.`);
+      return 0;
+    }
+  }
+  if (!repo || !path || !RecordId.safeParse(repo).success) {
+    io.err("Say which file: atticus cites --repo <repo> --path <its path in the repo>, or --file <path on disk>.");
+    return 2;
+  }
+  const v = await citeList(root, index, repo, path);
+  if (o.json) {
+    io.out(JSON.stringify(v, null, 2));
+    return 0;
+  }
+  if (!v.lines.length) {
+    io.out(`Nothing in the specs or the catalog cites ${repo}/${path}.`);
+    return 0;
+  }
+  for (const l of v.lines) {
+    const flows = l.flows.map((f) => `${f.name} (step ${f.step})${f.changes?.length ? `, changed by ${f.changes.join(", ")}` : ""}`);
+    const records = l.records.map((r) => `${r.kind} ${r.name ?? r.id}`);
+    io.out(`Line ${l.line}: ${[...flows, ...records].join("; ")}`);
+  }
+  return 0;
+}
+function uiCiteRoutes(r, ctx) {
+  const root = ctx.root;
+  let cached;
+  const indexNow = async () => {
+    const print = await fingerprint([specsDirOf(root), catalogDirOf(root)]);
+    if (cached?.print !== print)
+      cached = { print, index: build(root) };
+    return cached.index;
+  };
+  void indexNow().catch(() => void 0);
+  r.add("GET", "/api/cites", async ({ query }) => {
+    const repo = query.get("repo");
+    const path = query.get("path");
+    if (!repo || !RecordId.safeParse(repo).success)
+      throw badRequest("Say which repo: ?repo=<the repo's id>.");
+    if (!path)
+      throw badRequest("Say which file: ?path=<its path in the repo>.");
+    return { status: 200, body: await citeList(root, await indexNow(), repo, path) };
+  });
+  return r;
+}
+
+export {
+  fileInRepo,
+  citesCli,
+  uiCiteRoutes
+};

package/dist/chunk-TCADP67G.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-WIMOJMAK.js";
+import {
+  documentFormat,
+  readDocument
+} from "./chunk-5V5BJACL.js";
+import {
+  inputsDirOf
+} from "./chunk-JMOLB347.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
+};