agentskeptic 0.1.1

package/scripts/discovery-acquisition.lib.cjs

@@ -0,0 +1,195 @@
+"use strict";
+
+const { readFileSync } = require("node:fs");
+const { join } = require("node:path");
+const Ajv = require("ajv");
+const addFormats = require("ajv-formats");
+
+const PLACEHOLDER_KEYS = [
+  ["{{ORIGIN}}", "ORIGIN"],
+  ["{{ACQUISITION_PATH}}", "ACQUISITION_PATH"],
+  ["{{HERO_TITLE}}", "HERO_TITLE"],
+  ["{{HERO_SUBTITLE}}", "HERO_SUBTITLE"],
+  ["{{VISITOR_PROBLEM_ANSWER}}", "VISITOR_PROBLEM_ANSWER"],
+  ["{{TERMINAL_TITLE}}", "TERMINAL_TITLE"],
+  ["{{TERMINAL_TRANSCRIPT}}", "TERMINAL_TRANSCRIPT"],
+];
+
+/**
+ * @param {string} root
+ */
+function discoveryPaths(root) {
+  return {
+    jsonPath: join(root, "config", "discovery-acquisition.json"),
+    schemaPath: join(root, "config", "discovery-acquisition.schema.json"),
+  };
+}
+
+/**
+ * @param {string} root
+ */
+function loadDiscoveryAcquisition(root) {
+  const { jsonPath } = discoveryPaths(root);
+  return JSON.parse(readFileSync(jsonPath, "utf8"));
+}
+
+/**
+ * @param {Record<string, unknown>} discovery
+ * @param {string} originNormalized
+ */
+function buildDiscoveryFoldBody(discovery, originNormalized) {
+  const slug = String(discovery.slug);
+  const demo = /** @type {{ title: string; transcript: string }} */ (discovery.shareableTerminalDemo);
+  const map = {
+    "{{ORIGIN}}": originNormalized,
+    "{{ACQUISITION_PATH}}": slug,
+    "{{HERO_TITLE}}": String(discovery.heroTitle),
+    "{{HERO_SUBTITLE}}": String(discovery.heroSubtitle),
+    "{{VISITOR_PROBLEM_ANSWER}}": String(discovery.visitorProblemAnswer),
+    "{{TERMINAL_TITLE}}": String(demo.title),
+    "{{TERMINAL_TRANSCRIPT}}": String(demo.transcript),
+  };
+  const lines = discovery.readmeFold.templateLines.map((line) => substituteTemplateLine(String(line), map));
+  const body = lines.join("\n");
+  const label = String(discovery.homepageAcquisitionCtaLabel);
+  const mdLink = `\n\n[${escapeMdLinkText(label)}](${originNormalized}${slug})`;
+  const full = body + mdLink;
+  const urlInParens = `(${originNormalized}${slug})`;
+  if (!full.includes(urlInParens)) {
+    throw new Error("discovery-acquisition: fold body must include markdown URL in parentheses");
+  }
+  return full;
+}
+
+/**
+ * @param {string} line
+ * @param {Record<string, string>} map
+ */
+function substituteTemplateLine(line, map) {
+  let out = line;
+  for (const [token, _] of PLACEHOLDER_KEYS) {
+    if (out.includes(token) && map[token] !== undefined) {
+      out = out.split(token).join(map[token]);
+    }
+  }
+  if (out.includes("{{")) {
+    throw new Error(`discovery-acquisition: unresolved placeholder in template line: ${line}`);
+  }
+  return out;
+}
+
+/**
+ * @param {string} s
+ */
+function escapeMdLinkText(s) {
+  return s.replace(/\\/g, "\\\\").replace(/\[/g, "\\[").replace(/\]/g, "\\]");
+}
+
+/**
+ * @param {Record<string, unknown>} discovery
+ */
+function validateIndexableGuides(discovery) {
+  const guides = /** @type {{ path: string; navLabel: string; problemAnchor: string }[]} */ (
+    discovery.indexableGuides
+  );
+  if (!Array.isArray(guides)) {
+    throw new Error("discovery-acquisition: indexableGuides must be an array");
+  }
+  const paths = guides.map((g) => String(g.path));
+  const uniq = new Set(paths);
+  if (uniq.size !== paths.length) {
+    throw new Error("discovery-acquisition: indexableGuides paths must be unique");
+  }
+  const demandMoments = /** @type {string[]} */ (discovery.demandMoments);
+  for (let k = 0; k < guides.length; k++) {
+    const pa = String(guides[k].problemAnchor);
+    if (pa.includes("`")) {
+      throw new Error("discovery-acquisition: problemAnchor must not contain backtick");
+    }
+    if (k >= 1) {
+      const dm = String(demandMoments[k - 1]);
+      if (!dm.includes(pa)) {
+        throw new Error(
+          `discovery-acquisition: indexableGuides[${k}].problemAnchor must be a substring of demandMoments[${k - 1}]`,
+        );
+      }
+    }
+  }
+}
+
+/**
+ * @param {string} baseLlms
+ * @param {Record<string, unknown>} discovery
+ * @param {string} canonicalOrigin
+ */
+function appendDiscoveryLlmsAppendix(baseLlms, discovery, canonicalOrigin) {
+  const slug = String(discovery.slug);
+  const origin = canonicalOrigin;
+  const llms = discovery.llms;
+  const bullets = (/** @type {string[]} */ arr) => arr.map((x) => `- ${x}`).join("\n");
+
+  let out = String(baseLlms).replace(/\s*$/, "") + "\n";
+  const guides = /** @type {{ path: string }[] | undefined} */ (discovery.indexableGuides);
+  if (Array.isArray(guides) && guides.length > 0) {
+    out += "\n## Indexable guides\n";
+    for (const g of guides) {
+      out += `- ${origin}${String(g.path)}\n`;
+    }
+  }
+  const demo = discovery.shareableTerminalDemo;
+  if (demo && typeof demo.title === "string" && typeof demo.transcript === "string") {
+    out += `\n## ${demo.title}\n\n\`\`\`text\n${demo.transcript}\n\`\`\`\n`;
+  }
+  out += "\n## Intent phrases\n";
+  out += bullets(llms.intentPhrases) + "\n";
+  out += "\n## Not for\n";
+  out += bullets(llms.notFor) + "\n";
+  out += "\n## Related queries\n";
+  out += bullets(llms.relatedQueries) + "\n";
+  const moments = /** @type {string[]} */ (discovery.demandMoments);
+  out += "\n## When this hurts (search-shaped)\n";
+  out += bullets(moments) + "\n";
+  out += "\n## Problem framing (shareable)\n";
+  out += `- Full page: ${origin}${slug}\n`;
+  out += "\n## Visitor problem (canonical answer)\n\n";
+  out += String(discovery.visitorProblemAnswer) + "\n";
+  return out;
+}
+
+/**
+ * @param {string} root
+ */
+function validateDiscoveryAcquisition(root) {
+  const { jsonPath, schemaPath } = discoveryPaths(root);
+  const discovery = JSON.parse(readFileSync(jsonPath, "utf8"));
+  const schema = JSON.parse(readFileSync(schemaPath, "utf8"));
+  const ajv = new Ajv({ allErrors: true, strict: true });
+  addFormats(ajv);
+  const validate = ajv.compile(schema);
+  if (!validate(discovery)) {
+    const msg = ajv.errorsText(validate.errors, { separator: "\n" });
+    throw new Error(`discovery-acquisition: schema validation failed:\n${msg}`);
+  }
+  const anchorsPath = join(root, "config", "public-product-anchors.json");
+  const anchors = JSON.parse(readFileSync(anchorsPath, "utf8"));
+  const { normalize } = require("./public-product-anchors.cjs");
+  const origin = normalize(anchors.productionCanonicalOrigin);
+  buildDiscoveryFoldBody(discovery, origin);
+  const demo = discovery.shareableTerminalDemo;
+  if (demo && String(demo.transcript).includes("```")) {
+    throw new Error(
+      "discovery-acquisition: shareableTerminalDemo.transcript must not contain markdown fence ```",
+    );
+  }
+  validateIndexableGuides(discovery);
+  return discovery;
+}
+
+module.exports = {
+  loadDiscoveryAcquisition,
+  buildDiscoveryFoldBody,
+  appendDiscoveryLlmsAppendix,
+  validateDiscoveryAcquisition,
+  validateIndexableGuides,
+  discoveryPaths,
+};

package/scripts/discovery-payload.lib.cjs

@@ -0,0 +1,346 @@
+"use strict";
+
+const { readFileSync } = require("node:fs");
+const { join } = require("node:path");
+
+/**
+ * Same origin normalization as public-product-anchors.cjs (duplicated to avoid circular require).
+ * @param {string} s
+ */
+function normalizeOrigin(s) {
+  const t = String(s).trim();
+  if (!t) throw new Error("normalizeOrigin: empty origin");
+  const u = new URL(t);
+  return u.origin;
+}
+
+/** @type {const} */
+const DISCOVERY_LLM_BRANCH = "main";
+
+/** @type {const} */
+const PR_MARKER_LINE = "<!-- agentskeptic-discovery:v1 -->";
+
+/** @type {const} */
+const PR_MARKER_LINE_LEGACY = "<!-- workflow-verifier-discovery:v1 -->";
+
+const MAX_SUMMARY_UTF8_BYTES = 65536;
+const MAX_PR_BODY_UTF8_BYTES = 10240;
+const STDERR_TAIL_LINES = 20;
+
+/**
+ * @param {string} gitRepositoryUrl
+ * @returns {{ owner: string, repo: string }}
+ */
+function parseGithubRepoFromUrl(gitRepositoryUrl) {
+  const u = String(gitRepositoryUrl);
+  const m = u.match(/github\.com\/([^/]+)\/([^/#?]+)/i);
+  if (!m) {
+    throw new Error("discovery-payload: cannot parse owner/repo from gitRepositoryUrl");
+  }
+  const repo = m[2].replace(/\.git$/i, "");
+  return { owner: m[1], repo };
+}
+
+/**
+ * @param {string} s
+ */
+function utf8ByteLength(s) {
+  return Buffer.byteLength(s, "utf8");
+}
+
+/**
+ * @param {string} label
+ * @param {string} s
+ * @param {number} maxBytes
+ */
+function assertUtf8ByteLength(label, s, maxBytes) {
+  const n = utf8ByteLength(s);
+  if (n > maxBytes) {
+    throw new Error(`${label}: UTF-8 length ${n} exceeds max ${maxBytes}`);
+  }
+}
+
+/**
+ * CRLF → LF, trim trailing whitespace/newlines, exactly one trailing LF.
+ * @param {string} s
+ */
+function normalizeDiscoveryText(s) {
+  let t = String(s).replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  t = t.replace(/\s+$/, "");
+  return `${t}\n`;
+}
+
+/**
+ * @param {string} text
+ * @param {number} n
+ */
+function tailLines(text, n) {
+  const lines = normalizeDiscoveryText(text)
+    .replace(/\n$/, "")
+    .split("\n");
+  if (lines.length === 1 && lines[0] === "") return [];
+  const k = Math.max(0, Math.min(n, lines.length));
+  return lines.slice(lines.length - k);
+}
+
+/**
+ * @param {string} root
+ */
+function buildDiscoveryPayload(root) {
+  const discoveryLib = require("./discovery-acquisition.lib.cjs");
+  discoveryLib.validateDiscoveryAcquisition(root);
+  const discovery = discoveryLib.loadDiscoveryAcquisition(root);
+  const anchorsPath = join(root, "config", "public-product-anchors.json");
+  const anchors = JSON.parse(readFileSync(anchorsPath, "utf8"));
+  const canonicalOrigin = normalizeOrigin(anchors.productionCanonicalOrigin);
+  const integrateUrl = `${canonicalOrigin}/integrate`;
+  const openapiSelfCanonical = `${canonicalOrigin}/openapi-commercial-v1.yaml`;
+  const { owner, repo } = parseGithubRepoFromUrl(anchors.gitRepositoryUrl);
+  const llmsRaw = `https://raw.githubusercontent.com/${owner}/${repo}/refs/heads/${DISCOVERY_LLM_BRANCH}/llms.txt`;
+  const llmsBlob = `https://github.com/${owner}/${repo}/blob/${DISCOVERY_LLM_BRANCH}/llms.txt`;
+  const openapiRaw = `https://raw.githubusercontent.com/${owner}/${repo}/refs/heads/${DISCOVERY_LLM_BRANCH}/schemas/openapi-commercial-v1.yaml`;
+  const llms = /** @type {{ intentPhrases: string[]; notFor: string[]; relatedQueries: string[] }} */ (
+    discovery.llms
+  );
+  const demo = /** @type {{ title: string; transcript: string }} */ (discovery.shareableTerminalDemo);
+  return {
+    schemaVersion: 1,
+    identityOneLiner: String(anchors.identityOneLiner),
+    llmBranch: DISCOVERY_LLM_BRANCH,
+    links: {
+      site: `${canonicalOrigin}/`,
+      integrate: integrateUrl,
+      openapiCanonical: openapiSelfCanonical,
+      openapiRaw,
+      repo: String(anchors.gitRepositoryUrl),
+      npm: String(anchors.npmPackageUrl),
+      llmsRaw,
+      llmsBlob,
+    },
+    appendix: {
+      slug: String(discovery.slug),
+      visitorProblemAnswer: String(discovery.visitorProblemAnswer),
+      intentPhrases: llms.intentPhrases.map(String),
+      notFor: llms.notFor.map(String),
+      relatedQueries: llms.relatedQueries.map(String),
+      demandMoments: /** @type {string[]} */ (discovery.demandMoments).map(String),
+      indexableGuides: /** @type {unknown} */ (discovery.indexableGuides),
+      shareableTerminalDemo: {
+        title: String(demo.title),
+        transcript: String(demo.transcript),
+      },
+    },
+  };
+}
+
+/**
+ * @param {Record<string, unknown>} payload
+ */
+function discoveryObjectFromAppendix(payload) {
+  const ap = /** @type {{ slug: string; visitorProblemAnswer: string; intentPhrases: string[]; notFor: string[]; relatedQueries: string[]; demandMoments: string[]; indexableGuides?: { path: string; navLabel: string; problemAnchor: string }[]; shareableTerminalDemo?: { title: string; transcript: string } }} */ (
+    payload.appendix
+  );
+  const out = {
+    slug: ap.slug,
+    visitorProblemAnswer: ap.visitorProblemAnswer,
+    demandMoments: ap.demandMoments,
+    llms: {
+      intentPhrases: ap.intentPhrases,
+      notFor: ap.notFor,
+      relatedQueries: ap.relatedQueries,
+    },
+  };
+  if (ap.shareableTerminalDemo) {
+    Object.assign(out, { shareableTerminalDemo: ap.shareableTerminalDemo });
+  }
+  if (Array.isArray(ap.indexableGuides)) {
+    Object.assign(out, { indexableGuides: ap.indexableGuides });
+  }
+  return out;
+}
+
+/**
+ * @param {Record<string, unknown>} payload
+ */
+function renderLlmsTextFromPayload(payload) {
+  if (payload.schemaVersion !== 1) throw new Error("discovery-payload: unsupported schemaVersion");
+  const links = /** @type {Record<string, string>} */ (payload.links);
+  const anchorsLike = {
+    identityOneLiner: payload.identityOneLiner,
+    gitRepositoryUrl: links.repo,
+    npmPackageUrl: links.npm,
+  };
+  const canonicalOrigin = links.site.replace(/\/$/, "");
+  const integrateUrl = links.integrate;
+  const openapiSelfCanonical = links.openapiCanonical;
+  const lines = [
+    "# AgentSkeptic",
+    "",
+    "## Summary",
+    String(payload.identityOneLiner),
+    "",
+    "## Primary links",
+    `- Canonical site: ${links.site}`,
+    `- First-run integration: ${integrateUrl}`,
+    `- OpenAPI (canonical): ${openapiSelfCanonical}`,
+    `- OpenAPI (repo raw): ${links.openapiRaw}`,
+    `- Source repository: ${links.repo}`,
+    `- npm package: ${links.npm}`,
+    `- llms.txt (repo raw): ${links.llmsRaw}`,
+    "",
+  ];
+  const base = lines.join("\n");
+  const { appendDiscoveryLlmsAppendix } = require("./discovery-acquisition.lib.cjs");
+  const synthetic = discoveryObjectFromAppendix(payload);
+  const raw = appendDiscoveryLlmsAppendix(base, synthetic, canonicalOrigin);
+  return normalizeDiscoveryText(raw);
+}
+
+/**
+ * @param {Record<string, unknown>} payload
+ */
+function renderCiSummaryMarkdownFromPayload(payload) {
+  if (payload.schemaVersion !== 1) throw new Error("discovery-payload: unsupported schemaVersion");
+  const L = /** @type {Record<string, string>} */ (payload.links);
+  const lines = [
+    "## AgentSkeptic",
+    "",
+    String(payload.identityOneLiner),
+    "",
+    "- Canonical site: " + L.site,
+    "- Integrate: " + L.integrate,
+    "- OpenAPI: " + L.openapiCanonical,
+    "- OpenAPI (repo raw): " + L.openapiRaw,
+    "- Repository: " + L.repo,
+    "- npm: " + L.npm,
+    "- llms.txt (raw): " + L.llmsRaw,
+    "- llms.txt (blob): " + L.llmsBlob,
+    "",
+  ];
+  const out = lines.join("\n");
+  assertUtf8ByteLength("ci_summary_markdown", out, MAX_SUMMARY_UTF8_BYTES);
+  return normalizeDiscoveryText(out);
+}
+
+/**
+ * @param {string} stderrText
+ */
+function formatStderrBlock(stderrText) {
+  const trimmed = String(stderrText).trim();
+  if (!trimmed) {
+    return "## CLI stderr (last 20 lines)\n\n_(no stderr)_\n";
+  }
+  const tail = tailLines(trimmed, STDERR_TAIL_LINES);
+  const body = tail.join("\n");
+  return `## CLI stderr (last ${STDERR_TAIL_LINES} lines)\n\n\`\`\`text\n${body}\n\`\`\`\n`;
+}
+
+/**
+ * Assemble PR body: header → optional verdict → stderr → footer → marker.
+ * Truncates stderr block from the start only until UTF-8 length ≤ max.
+ *
+ * @param {Record<string, unknown>} payload
+ * @param {{ stderrText: string; workflowStdoutText: string }} capture
+ */
+function renderCiPrBodyFromPayload(payload, capture) {
+  if (payload.schemaVersion !== 1) throw new Error("discovery-payload: unsupported schemaVersion");
+  const L = /** @type {Record<string, string>} */ (payload.links);
+  const stderrText = capture.stderrText ?? "";
+  const workflowStdoutText = capture.workflowStdoutText ?? "";
+
+  const header = `## AgentSkeptic — verification failed
+
+${String(payload.identityOneLiner)}
+
+`;
+
+  const verdictTrim = String(workflowStdoutText).trim();
+  const oneLine =
+    verdictTrim.length > 0 ? verdictTrim.split("\n")[0].slice(0, 500) : "";
+  const verdictSection = oneLine
+    ? ["## Verification stdout (first line)", "", "```", oneLine, "```", ""].join("\n")
+    : "";
+
+  let stderrBlock = formatStderrBlock(stderrText);
+
+  const footer = [
+    "---",
+    "",
+    "- " + L.site,
+    "- " + L.integrate,
+    "- " + L.repo,
+    "",
+    PR_MARKER_LINE,
+    "",
+  ].join("\n");
+
+  function assemble(verdict, sb) {
+    const raw = header + verdict + sb + footer;
+    return normalizeDiscoveryText(raw);
+  }
+
+  let body = assemble(verdictSection, stderrBlock);
+  if (utf8ByteLength(body) <= MAX_PR_BODY_UTF8_BYTES) {
+    return body;
+  }
+
+  const stderrLines = stderrText.trim() ? tailLines(stderrText, STDERR_TAIL_LINES) : [];
+  for (let drop = 1; drop <= stderrLines.length; drop++) {
+    const shortened = stderrLines.slice(drop);
+    const inner = shortened.length ? shortened.join("\n") : "";
+    stderrBlock = inner
+      ? `## CLI stderr (last ${STDERR_TAIL_LINES} lines)\n\n\`\`\`text\n${inner}\n\`\`\`\n`
+      : "## CLI stderr (last 20 lines)\n\n_(no stderr)_\n";
+    body = assemble(verdictSection, stderrBlock);
+    if (utf8ByteLength(body) <= MAX_PR_BODY_UTF8_BYTES) return body;
+  }
+
+  stderrBlock = "## CLI stderr (last 20 lines)\n\n_(no stderr)_\n";
+  body = assemble(verdictSection, stderrBlock);
+  if (utf8ByteLength(body) <= MAX_PR_BODY_UTF8_BYTES) return body;
+
+  if (verdictSection) {
+    body = assemble("", stderrBlock);
+    if (utf8ByteLength(body) <= MAX_PR_BODY_UTF8_BYTES) return body;
+  }
+
+  throw new Error(
+    `discovery-payload: PR body still exceeds ${MAX_PR_BODY_UTF8_BYTES} bytes after truncation`,
+  );
+}
+
+/**
+ * GitHub list issue comments returns ascending creation time.
+ * Pick the newest comment whose body includes the marker.
+ * @param {Array<{ id: number; body?: string | null }>} comments
+ * @param {string} marker
+ * @returns {{ action: 'create' } | { action: 'update'; id: number }}
+ */
+function selectPrCommentUpsert(comments, marker) {
+  const withMarker = comments.filter((c) => {
+    const b = String(c.body ?? "");
+    return b.includes(marker) || b.includes(PR_MARKER_LINE_LEGACY);
+  });
+  if (withMarker.length === 0) return { action: "create" };
+  const newest = withMarker[withMarker.length - 1];
+  return { action: "update", id: newest.id };
+}
+
+module.exports = {
+  DISCOVERY_LLM_BRANCH,
+  PR_MARKER_LINE,
+  PR_MARKER_LINE_LEGACY,
+  MAX_SUMMARY_UTF8_BYTES,
+  MAX_PR_BODY_UTF8_BYTES,
+  STDERR_TAIL_LINES,
+  buildDiscoveryPayload,
+  normalizeDiscoveryText,
+  utf8ByteLength,
+  assertUtf8ByteLength,
+  tailLines,
+  renderLlmsTextFromPayload,
+  renderCiSummaryMarkdownFromPayload,
+  renderCiPrBodyFromPayload,
+  parseGithubRepoFromUrl,
+  selectPrCommentUpsert,
+};

package/scripts/render-discovery-ci.mjs

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const require = createRequire(import.meta.url);
+const {
+  renderCiSummaryMarkdownFromPayload,
+  renderCiPrBodyFromPayload,
+} = require("./discovery-payload.lib.cjs");
+
+function usage() {
+  return `Usage:
+  node scripts/render-discovery-ci.mjs summary
+  node scripts/render-discovery-ci.mjs pr_body --stderr-file PATH --workflow-stdout-file PATH
+
+Environment:
+  AS_REPO_ROOT    Root of installed agentskeptic package (preferred)
+  WFV_REPO_ROOT   Legacy alias for AS_REPO_ROOT (default: parent of scripts/)
+`;
+}
+
+function resolveRoot() {
+  const e = process.env.AS_REPO_ROOT || process.env.WFV_REPO_ROOT;
+  if (e && String(e).trim()) return path.resolve(String(e).trim());
+  return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+}
+
+function loadPayload(root) {
+  const p = path.join(root, "dist", "discovery-payload-v1.json");
+  const raw = readFileSync(p, "utf8");
+  const payload = JSON.parse(raw);
+  if (payload.schemaVersion !== 1) {
+    console.error("render-discovery-ci: discovery-payload-v1.json schemaVersion must be 1");
+    process.exit(2);
+  }
+  return payload;
+}
+
+function main() {
+  const argv = process.argv.slice(2);
+  if (argv.length < 1) {
+    console.error(usage());
+    process.exit(2);
+  }
+  const mode = argv[0];
+  if (mode !== "summary" && mode !== "pr_body") {
+    console.error(usage());
+    process.exit(2);
+  }
+
+  const root = resolveRoot();
+  let payload;
+  try {
+    payload = loadPayload(root);
+  } catch (e) {
+    console.error(
+      e instanceof Error ? e.message : e,
+      "\nrender-discovery-ci: failed to read dist/discovery-payload-v1.json — run build first.",
+    );
+    process.exit(2);
+  }
+
+  if (mode === "summary") {
+    if (argv.length !== 1) {
+      console.error(usage());
+      process.exit(2);
+    }
+    process.stdout.write(renderCiSummaryMarkdownFromPayload(payload));
+    return;
+  }
+
+  let stderrPath = "";
+  let stdoutPath = "";
+  for (let i = 1; i < argv.length; i++) {
+    if (argv[i] === "--stderr-file" && argv[i + 1]) {
+      stderrPath = argv[++i];
+    } else if (argv[i] === "--workflow-stdout-file" && argv[i + 1]) {
+      stdoutPath = argv[++i];
+    } else {
+      console.error(usage());
+      process.exit(2);
+    }
+  }
+  if (!stderrPath || !stdoutPath) {
+    console.error(usage());
+    process.exit(2);
+  }
+
+  const stderrText = readFileSync(stderrPath, "utf8");
+  const workflowStdoutText = readFileSync(stdoutPath, "utf8");
+  process.stdout.write(
+    renderCiPrBodyFromPayload(payload, { stderrText, workflowStdoutText }),
+  );
+}
+
+try {
+  main();
+} catch (e) {
+  console.error(e instanceof Error ? e.message : e);
+  process.exit(1);
+}