@pactosigna/records 0.1.0

package/dist/index.js

@@ -0,0 +1,1167 @@
+// src/generate.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { resolve as pathResolve } from "path";
+import PdfPrinterModule from "pdfmake/js/Printer.js";
+
+// src/config.ts
+import { z } from "zod";
+import { readFileSync, existsSync } from "fs";
+import { resolve } from "path";
+import { parse as parseYaml } from "yaml";
+var BrandingSchema = z.object({
+  logo: z.string().optional()
+}).default({});
+var ReleaseConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  attach_pdfs: z.boolean().default(true)
+}).default({});
+var RecordsConfigSchema = z.object({
+  branding: BrandingSchema.default({}),
+  signatures: z.array(z.string()).default(["Author", "Reviewer", "Approver"]),
+  release: ReleaseConfigSchema.default({})
+});
+function loadConfig(rootDir) {
+  const configPath = resolve(rootDir, "pactosigna.yaml");
+  if (!existsSync(configPath)) {
+    return RecordsConfigSchema.parse({});
+  }
+  const raw = readFileSync(configPath, "utf-8");
+  const parsed = parseYaml(raw);
+  const recordsSection = parsed.records ?? {};
+  return RecordsConfigSchema.parse(recordsSection);
+}
+
+// src/reader/markdown-reader.ts
+import { readdirSync, readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve2, join } from "path";
+import matter from "gray-matter";
+var INCLUDED_STATUSES = /* @__PURE__ */ new Set(["approved", "effective"]);
+function readDocuments(rootDir, folderPath, statusFilter = INCLUDED_STATUSES) {
+  const fullPath = resolve2(rootDir, folderPath);
+  let files;
+  try {
+    files = readdirSync(fullPath).filter((f) => f.endsWith(".md"));
+  } catch {
+    return [];
+  }
+  const docs = [];
+  const warnings = [];
+  for (const file of files) {
+    const filePath = join(folderPath, file);
+    const raw = readFileSync2(resolve2(rootDir, filePath), "utf-8");
+    const { data, content } = matter(raw);
+    if (!data.id || !data.title || !data.status) {
+      warnings.push(`Skipping ${filePath}: missing required frontmatter (id, title, or status)`);
+      continue;
+    }
+    if (!statusFilter.has(data.status)) {
+      continue;
+    }
+    docs.push({
+      frontmatter: data,
+      body: content.trim(),
+      filePath
+    });
+  }
+  for (const w of warnings) {
+    console.warn(w);
+  }
+  return docs.sort(
+    (a, b) => a.frontmatter.id.localeCompare(b.frontmatter.id, void 0, { numeric: true })
+  );
+}
+
+// src/pdf/markdown-to-pdfmake.ts
+import MarkdownIt from "markdown-it";
+var md = new MarkdownIt();
+function markdownToPdfmake(markdown) {
+  if (!markdown.trim()) return [];
+  const tokens = md.parse(markdown, {});
+  const result = [];
+  let i = 0;
+  while (i < tokens.length) {
+    const token = tokens[i];
+    if (token.type === "heading_open") {
+      const level = token.tag;
+      const inlineToken = tokens[i + 1];
+      const fragments = inlineToken ? parseInlineContent(inlineToken) : [];
+      result.push({
+        text: fragments.length === 1 && typeof fragments[0] === "string" ? fragments[0] : fragments,
+        style: level,
+        margin: [0, 12, 0, 4]
+      });
+      i += 3;
+      continue;
+    }
+    if (token.type === "paragraph_open") {
+      const inlineToken = tokens[i + 1];
+      const fragments = inlineToken ? parseInlineContent(inlineToken) : [];
+      result.push({
+        text: fragments,
+        margin: [0, 0, 0, 6]
+      });
+      i += 3;
+      continue;
+    }
+    if (token.type === "bullet_list_open") {
+      const { items, endIndex } = parseListItems(tokens, i + 1);
+      result.push({
+        ul: items,
+        margin: [0, 0, 0, 6]
+      });
+      i = endIndex + 1;
+      continue;
+    }
+    if (token.type === "ordered_list_open") {
+      const { items, endIndex } = parseListItems(tokens, i + 1);
+      result.push({
+        ol: items,
+        margin: [0, 0, 0, 6]
+      });
+      i = endIndex + 1;
+      continue;
+    }
+    if (token.type === "fence") {
+      result.push({
+        text: token.content,
+        style: "code",
+        margin: [0, 4, 0, 4],
+        background: "#F5F5F5"
+      });
+      i += 1;
+      continue;
+    }
+    if (token.type === "table_open") {
+      const { table, endIndex } = parseTable(tokens, i + 1);
+      result.push(table);
+      i = endIndex + 1;
+      continue;
+    }
+    i += 1;
+  }
+  return result;
+}
+function parseInlineContent(token) {
+  const children = token.children ?? [];
+  const fragments = [];
+  let bold = false;
+  let italics = false;
+  for (const child of children) {
+    switch (child.type) {
+      case "strong_open":
+        bold = true;
+        break;
+      case "strong_close":
+        bold = false;
+        break;
+      case "em_open":
+        italics = true;
+        break;
+      case "em_close":
+        italics = false;
+        break;
+      case "code_inline":
+        fragments.push({ text: child.content, font: "Courier", fontSize: 9 });
+        break;
+      case "softbreak":
+      case "hardbreak":
+        fragments.push("\n");
+        break;
+      case "text":
+        if (bold || italics) {
+          const fragment = { text: child.content };
+          if (bold) fragment.bold = true;
+          if (italics) fragment.italics = true;
+          fragments.push(fragment);
+        } else {
+          fragments.push(child.content);
+        }
+        break;
+      default:
+        if (child.content) {
+          fragments.push(child.content);
+        }
+        break;
+    }
+  }
+  return fragments;
+}
+function parseListItems(tokens, startIndex) {
+  const items = [];
+  let i = startIndex;
+  while (i < tokens.length) {
+    const token = tokens[i];
+    if (token.type === "bullet_list_close" || token.type === "ordered_list_close") {
+      return { items, endIndex: i };
+    }
+    if (token.type === "list_item_open") {
+      const inlineToken = tokens[i + 2];
+      if (inlineToken?.type === "inline") {
+        const fragments = parseInlineContent(inlineToken);
+        items.push({
+          text: fragments
+        });
+      }
+      while (i < tokens.length && tokens[i].type !== "list_item_close") {
+        i += 1;
+      }
+      i += 1;
+      continue;
+    }
+    i += 1;
+  }
+  return { items, endIndex: i - 1 };
+}
+function parseTable(tokens, startIndex) {
+  const rows = [];
+  let currentRow = [];
+  let i = startIndex;
+  while (i < tokens.length) {
+    const token = tokens[i];
+    if (token.type === "table_close") {
+      return {
+        table: {
+          table: {
+            headerRows: 1,
+            body: rows
+          },
+          layout: "lightHorizontalLines",
+          margin: [0, 4, 0, 8]
+        },
+        endIndex: i
+      };
+    }
+    if (token.type === "tr_open") {
+      currentRow = [];
+      i += 1;
+      continue;
+    }
+    if (token.type === "tr_close") {
+      if (currentRow.length > 0) {
+        rows.push(currentRow);
+      }
+      i += 1;
+      continue;
+    }
+    if (token.type === "th_open" || token.type === "td_open") {
+      const inlineToken = tokens[i + 1];
+      if (inlineToken?.type === "inline") {
+        const fragments = parseInlineContent(inlineToken);
+        const isHeader = token.type === "th_open";
+        currentRow.push({
+          text: fragments,
+          bold: isHeader || void 0
+        });
+      } else {
+        currentRow.push({ text: "" });
+      }
+      while (i < tokens.length && tokens[i].type !== "th_close" && tokens[i].type !== "td_close") {
+        i += 1;
+      }
+      i += 1;
+      continue;
+    }
+    i += 1;
+  }
+  return {
+    table: {
+      table: { headerRows: 1, body: rows },
+      layout: "lightHorizontalLines",
+      margin: [0, 4, 0, 8]
+    },
+    endIndex: i - 1
+  };
+}
+
+// src/pdf/layout.ts
+var HEADER_GRAY = "#F0F0F0";
+var HEADING_COLOR = "#2C3E50";
+var SIGNATURE_ROW_HEIGHT = 30;
+function buildCoverPage(options) {
+  const { config, revisionHistory } = options;
+  const signatureHeaders = [
+    { text: "Role", bold: true, fillColor: HEADER_GRAY },
+    { text: "Name", bold: true, fillColor: HEADER_GRAY },
+    { text: "Signature", bold: true, fillColor: HEADER_GRAY },
+    { text: "Date", bold: true, fillColor: HEADER_GRAY }
+  ];
+  const signatureRows = config.signatures.map((role) => [
+    { text: role, margin: [0, 8, 0, 8] },
+    { text: "", margin: [0, 8, 0, 8] },
+    {
+      text: "",
+      margin: [0, 8, 0, 8],
+      minHeight: SIGNATURE_ROW_HEIGHT
+    },
+    { text: "", margin: [0, 8, 0, 8] }
+  ]);
+  const revisionHeaders = [
+    { text: "Revision", bold: true, fillColor: HEADER_GRAY },
+    { text: "Date", bold: true, fillColor: HEADER_GRAY },
+    { text: "Description", bold: true, fillColor: HEADER_GRAY }
+  ];
+  const revisionRows = revisionHistory.map((entry) => [
+    entry.revision,
+    entry.date,
+    entry.description
+  ]);
+  const cover = [
+    { text: "Signatures", bold: true, fontSize: 14, margin: [0, 0, 0, 8] },
+    {
+      table: {
+        headerRows: 1,
+        widths: ["auto", "*", "*", "auto"],
+        body: [signatureHeaders, ...signatureRows]
+      },
+      layout: "lightHorizontalLines"
+    },
+    { text: "Revision History", bold: true, fontSize: 14, margin: [0, 20, 0, 8] },
+    {
+      table: {
+        headerRows: 1,
+        widths: ["auto", "auto", "*"],
+        body: revisionRows.length > 0 ? [revisionHeaders, ...revisionRows] : [revisionHeaders, ["", "", ""]]
+      },
+      layout: "lightHorizontalLines"
+    },
+    { text: "", pageBreak: "after" }
+  ];
+  return cover;
+}
+function buildDocumentDefinition(options) {
+  const { recordTitle, recordId, version, date, content = [] } = options;
+  const coverPage = buildCoverPage(options);
+  return {
+    pageSize: "A4",
+    pageMargins: [40, 80, 40, 50],
+    defaultStyle: {
+      font: "Helvetica",
+      fontSize: 10
+    },
+    styles: {
+      h1: { fontSize: 18, bold: true },
+      h2: { fontSize: 14, bold: true, color: HEADING_COLOR },
+      h3: { fontSize: 12, bold: true },
+      h4: { fontSize: 11, bold: true },
+      code: { font: "Courier", fontSize: 9, background: "#F5F5F5" }
+    },
+    header: (_currentPage, _pageCount, pageSize) => {
+      const usableWidth = pageSize.width - 80;
+      return {
+        margin: [40, 15, 40, 0],
+        table: {
+          widths: [usableWidth * 0.2, "*", usableWidth * 0.25],
+          body: [
+            [
+              { text: "[LOGO]", fontSize: 8, color: "#999999" },
+              {
+                stack: [
+                  { text: recordTitle, bold: true, fontSize: 10, alignment: "center" },
+                  { text: recordId, fontSize: 8, alignment: "center", color: "#666666" }
+                ]
+              },
+              {
+                stack: [
+                  {
+                    text: `Rev: ${version}`,
+                    fontSize: 8,
+                    alignment: "right"
+                  },
+                  {
+                    text: `Date: ${date}`,
+                    fontSize: 8,
+                    alignment: "right",
+                    color: "#666666"
+                  }
+                ]
+              }
+            ]
+          ]
+        },
+        layout: {
+          hLineWidth: (i, node) => i === node.table.body.length ? 1 : 0,
+          vLineWidth: () => 0,
+          hLineColor: () => "#CCCCCC"
+        }
+      };
+    },
+    footer: (currentPage, pageCount) => ({
+      margin: [40, 10, 40, 0],
+      columns: [
+        { text: "", width: "*" },
+        {
+          text: `${recordId} \xB7 Rev ${version}`,
+          alignment: "center",
+          fontSize: 8,
+          color: "#999999",
+          width: "*"
+        },
+        {
+          text: `Page ${currentPage} of ${pageCount}`,
+          alignment: "right",
+          fontSize: 8,
+          color: "#999999",
+          width: "*"
+        }
+      ]
+    }),
+    content: [...coverPage, ...content]
+  };
+}
+
+// src/generators/urs-generator.ts
+function generateUrs(input) {
+  const docs = readDocuments(input.rootDir, "docs/product/user-needs");
+  if (docs.length === 0) {
+    console.warn("URS: no approved/effective user need documents found \u2014 skipping");
+    return null;
+  }
+  const content = [];
+  content.push({ text: "Table of Contents", style: "h2", margin: [0, 0, 0, 10] });
+  content.push({
+    ol: docs.map((d) => ({
+      text: `${d.frontmatter.id}: ${d.frontmatter.title}`,
+      margin: [0, 2, 0, 2]
+    }))
+  });
+  content.push({ text: "", pageBreak: "after" });
+  for (const doc of docs) {
+    content.push({
+      text: `${doc.frontmatter.id}: ${doc.frontmatter.title}`,
+      style: "h2",
+      margin: [0, 10, 0, 6]
+    });
+    content.push(...markdownToPdfmake(doc.body));
+    content.push({ text: "", margin: [0, 20, 0, 0] });
+  }
+  return buildDocumentDefinition({
+    config: input.config,
+    recordTitle: "User Requirements Specification",
+    recordId: "URS",
+    version: input.version,
+    date: input.date,
+    revisionHistory: input.revisionHistory,
+    content
+  });
+}
+
+// src/generators/prs-generator.ts
+function generatePrs(input) {
+  const docs = readDocuments(input.rootDir, "docs/product/requirements");
+  if (docs.length === 0) {
+    console.warn("PRS: no approved/effective product requirement documents found \u2014 skipping");
+    return null;
+  }
+  const content = [];
+  content.push({ text: "Table of Contents", style: "h2", margin: [0, 0, 0, 10] });
+  content.push({
+    ol: docs.map((d) => ({
+      text: `${d.frontmatter.id}: ${d.frontmatter.title}`,
+      margin: [0, 2, 0, 2]
+    }))
+  });
+  content.push({ text: "", pageBreak: "after" });
+  for (const doc of docs) {
+    content.push({
+      text: `${doc.frontmatter.id}: ${doc.frontmatter.title}`,
+      style: "h2",
+      margin: [0, 10, 0, 6]
+    });
+    content.push(...markdownToPdfmake(doc.body));
+    content.push({ text: "", margin: [0, 20, 0, 0] });
+  }
+  return buildDocumentDefinition({
+    config: input.config,
+    recordTitle: "Product Requirements Specification",
+    recordId: "PRS",
+    version: input.version,
+    date: input.date,
+    revisionHistory: input.revisionHistory,
+    content
+  });
+}
+
+// src/generators/srs-generator.ts
+function generateSrs(input) {
+  const docs = readDocuments(input.rootDir, "docs/software/requirements");
+  if (docs.length === 0) {
+    console.warn("SRS: no approved/effective software requirement documents found \u2014 skipping");
+    return null;
+  }
+  const content = [];
+  content.push({ text: "Table of Contents", style: "h2", margin: [0, 0, 0, 10] });
+  content.push({
+    ol: docs.map((d) => ({
+      text: `${d.frontmatter.id}: ${d.frontmatter.title}`,
+      margin: [0, 2, 0, 2]
+    }))
+  });
+  content.push({ text: "", pageBreak: "after" });
+  for (const doc of docs) {
+    content.push({
+      text: `${doc.frontmatter.id}: ${doc.frontmatter.title}`,
+      style: "h2",
+      margin: [0, 10, 0, 6]
+    });
+    content.push(...markdownToPdfmake(doc.body));
+    content.push({ text: "", margin: [0, 20, 0, 0] });
+  }
+  return buildDocumentDefinition({
+    config: input.config,
+    recordTitle: "Software Requirements Specification",
+    recordId: "SRS",
+    version: input.version,
+    date: input.date,
+    revisionHistory: input.revisionHistory,
+    content
+  });
+}
+
+// src/reader/document-resolver.ts
+var DOC_ID_PATTERN = /^[A-Z]+-(?:[A-Z]+-)?[0-9]+$/;
+var DocumentResolver = class {
+  index;
+  constructor(documents) {
+    this.index = new Map(documents.map((d) => [d.frontmatter.id, d]));
+  }
+  resolve(reference) {
+    const doc = this.index.get(reference);
+    if (doc) {
+      return `${doc.frontmatter.id}: ${doc.frontmatter.title}`;
+    }
+    if (DOC_ID_PATTERN.test(reference)) {
+      return `[UNRESOLVED: ${reference}]`;
+    }
+    return reference;
+  }
+  resolveAll(references) {
+    return references.map((r) => this.resolve(r));
+  }
+  getDocument(id) {
+    return this.index.get(id);
+  }
+};
+
+// src/generators/pta-generator.ts
+function getStringArray(value) {
+  if (Array.isArray(value)) {
+    return value.filter((v) => typeof v === "string");
+  }
+  return [];
+}
+function buildTraceabilityMatrix(uns, prss, srss) {
+  const allDocs = [...uns, ...prss, ...srss];
+  const resolver = new DocumentResolver(allDocs);
+  const unById = new Map(uns.map((d) => [d.frontmatter.id, d]));
+  const prsById = new Map(prss.map((d) => [d.frontmatter.id, d]));
+  const unToPrs = /* @__PURE__ */ new Map();
+  for (const un of uns) {
+    const derives = getStringArray(un.frontmatter.derives);
+    for (const prsId of derives) {
+      if (!unToPrs.has(un.frontmatter.id)) {
+        unToPrs.set(un.frontmatter.id, /* @__PURE__ */ new Set());
+      }
+      unToPrs.get(un.frontmatter.id).add(prsId);
+    }
+  }
+  for (const prs of prss) {
+    const tracesFrom = getStringArray(prs.frontmatter.traces_from);
+    for (const unId of tracesFrom) {
+      if (unById.has(unId)) {
+        if (!unToPrs.has(unId)) {
+          unToPrs.set(unId, /* @__PURE__ */ new Set());
+        }
+        unToPrs.get(unId).add(prs.frontmatter.id);
+      }
+    }
+  }
+  const prsToSrs = /* @__PURE__ */ new Map();
+  for (const prs of prss) {
+    const tracesTo = getStringArray(prs.frontmatter.traces_to);
+    for (const srsId of tracesTo) {
+      if (!prsToSrs.has(prs.frontmatter.id)) {
+        prsToSrs.set(prs.frontmatter.id, /* @__PURE__ */ new Set());
+      }
+      prsToSrs.get(prs.frontmatter.id).add(srsId);
+    }
+  }
+  for (const srs of srss) {
+    const tracesFrom = getStringArray(srs.frontmatter.traces_from);
+    for (const prsId of tracesFrom) {
+      if (prsById.has(prsId)) {
+        if (!prsToSrs.has(prsId)) {
+          prsToSrs.set(prsId, /* @__PURE__ */ new Set());
+        }
+        prsToSrs.get(prsId).add(srs.frontmatter.id);
+      }
+    }
+  }
+  const prsToSource = /* @__PURE__ */ new Map();
+  for (const [unId, prsIds] of unToPrs) {
+    for (const prsId of prsIds) {
+      if (!prsToSource.has(prsId)) {
+        prsToSource.set(prsId, /* @__PURE__ */ new Set());
+      }
+      prsToSource.get(prsId).add(unId);
+    }
+  }
+  for (const prs of prss) {
+    const tracesFrom = getStringArray(prs.frontmatter.traces_from);
+    for (const ref of tracesFrom) {
+      if (!unById.has(ref)) {
+        if (!prsToSource.has(prs.frontmatter.id)) {
+          prsToSource.set(prs.frontmatter.id, /* @__PURE__ */ new Set());
+        }
+        prsToSource.get(prs.frontmatter.id).add(ref);
+      }
+    }
+  }
+  const rows = [];
+  for (const prs of prss) {
+    const sourceRefs = prsToSource.get(prs.frontmatter.id);
+    const sources = sourceRefs ? [...sourceRefs].map((ref) => resolver.resolve(ref)).join(", ") : "";
+    const srsRefs = prsToSrs.get(prs.frontmatter.id);
+    const srsResolved = srsRefs ? [...srsRefs].map((ref) => resolver.resolve(ref)).join(", ") : "";
+    rows.push({
+      source: sources,
+      prs: `${prs.frontmatter.id}: ${prs.frontmatter.title}`,
+      srs: srsResolved
+    });
+  }
+  const gaps = [];
+  const unsWithPrs = /* @__PURE__ */ new Set();
+  for (const [unId, prsIds] of unToPrs) {
+    if (prsIds.size > 0) {
+      unsWithPrs.add(unId);
+    }
+  }
+  for (const un of uns) {
+    if (!unsWithPrs.has(un.frontmatter.id)) {
+      gaps.push({
+        id: un.frontmatter.id,
+        title: un.frontmatter.title,
+        type: "un_no_prs"
+      });
+    }
+  }
+  for (const prs of prss) {
+    const srsRefs = prsToSrs.get(prs.frontmatter.id);
+    if (!srsRefs || srsRefs.size === 0) {
+      gaps.push({
+        id: prs.frontmatter.id,
+        title: prs.frontmatter.title,
+        type: "prs_no_srs"
+      });
+    }
+  }
+  const srssWithPrs = /* @__PURE__ */ new Set();
+  for (const [, srsIds] of prsToSrs) {
+    for (const srsId of srsIds) {
+      srssWithPrs.add(srsId);
+    }
+  }
+  for (const srs of srss) {
+    if (!srssWithPrs.has(srs.frontmatter.id)) {
+      gaps.push({
+        id: srs.frontmatter.id,
+        title: srs.frontmatter.title,
+        type: "srs_no_prs"
+      });
+    }
+  }
+  return { rows, gaps };
+}
+var HEADER_GRAY2 = "#F0F0F0";
+var GAP_LABELS = {
+  un_no_prs: "User Need with no Product Requirement",
+  prs_no_srs: "Product Requirement with no Software Requirement",
+  srs_no_prs: "Software Requirement with no Product Requirement"
+};
+function generatePta(input) {
+  const uns = readDocuments(input.rootDir, "docs/product/user-needs");
+  const prss = readDocuments(input.rootDir, "docs/product/requirements");
+  const srss = readDocuments(input.rootDir, "docs/software/requirements");
+  if (prss.length === 0) {
+    console.warn("PTA: no approved/effective product requirement documents found \u2014 skipping");
+    return null;
+  }
+  const matrix = buildTraceabilityMatrix(uns, prss, srss);
+  const content = [];
+  content.push({
+    text: "Requirements Traceability Matrix",
+    style: "h2",
+    margin: [0, 0, 0, 10]
+  });
+  const tableHeaders = [
+    { text: "Source", bold: true, fillColor: HEADER_GRAY2 },
+    { text: "Product Requirement", bold: true, fillColor: HEADER_GRAY2 },
+    { text: "Software Requirement(s)", bold: true, fillColor: HEADER_GRAY2 }
+  ];
+  const tableBody = matrix.rows.map((row) => [
+    { text: row.source || "\u2014" },
+    { text: row.prs },
+    { text: row.srs || "\u2014" }
+  ]);
+  content.push({
+    table: {
+      headerRows: 1,
+      widths: ["*", "*", "*"],
+      body: [tableHeaders, ...tableBody]
+    },
+    layout: "lightHorizontalLines"
+  });
+  if (matrix.gaps.length > 0) {
+    content.push({
+      text: "Coverage Gaps",
+      style: "h2",
+      margin: [0, 20, 0, 10]
+    });
+    content.push({
+      ul: matrix.gaps.map((gap) => ({
+        text: `${gap.id}: ${gap.title} \u2014 ${GAP_LABELS[gap.type]}`,
+        margin: [0, 2, 0, 2]
+      }))
+    });
+  }
+  return buildDocumentDefinition({
+    config: input.config,
+    recordTitle: "Product Traceability Analysis",
+    recordId: "PTA",
+    version: input.version,
+    date: input.date,
+    revisionHistory: input.revisionHistory,
+    content
+  });
+}
+
+// src/pdf/risk-matrix.ts
+var COLOR_UNACCEPTABLE = "#FF6B6B";
+var COLOR_REVIEW_REQUIRED = "#FFD93D";
+var COLOR_ACCEPTABLE = "#90EE90";
+var COLOR_HEADER = "#F0F0F0";
+function getCellColor(p, s, config) {
+  const unacceptable = config.acceptability.unacceptable;
+  const reviewRequired = config.acceptability.review_required ?? [];
+  if (unacceptable.some(([cp, cs]) => cp === p && cs === s)) {
+    return COLOR_UNACCEPTABLE;
+  }
+  if (reviewRequired.some(([cp, cs]) => cp === p && cs === s)) {
+    return COLOR_REVIEW_REQUIRED;
+  }
+  return COLOR_ACCEPTABLE;
+}
+function buildRiskMatrixTable(config, riskCounts, probabilityAxis) {
+  const severityLabels = config.labels.severity;
+  const probabilityLabels = probabilityAxis === "exploitability" && config.labels.exploitability ? config.labels.exploitability : config.labels.probability;
+  const headerRow = [
+    { text: "", fillColor: COLOR_HEADER, bold: true, alignment: "center" },
+    ...severityLabels.map((label, i) => ({
+      text: `${i + 1}
+${label}`,
+      fillColor: COLOR_HEADER,
+      bold: true,
+      alignment: "center",
+      fontSize: 8
+    }))
+  ];
+  const dataRows = [];
+  for (let p = 5; p >= 1; p--) {
+    const labelIndex = p - 1;
+    const labelCell = {
+      text: `${p}
+${probabilityLabels[labelIndex]}`,
+      fillColor: COLOR_HEADER,
+      bold: true,
+      alignment: "center",
+      fontSize: 8
+    };
+    const cells = [];
+    for (let s = 1; s <= 5; s++) {
+      const count = riskCounts.get(`${p},${s}`) ?? 0;
+      cells.push({
+        text: count > 0 ? String(count) : "",
+        fillColor: getCellColor(p, s, config),
+        bold: count > 0,
+        alignment: "center"
+      });
+    }
+    dataRows.push([labelCell, ...cells]);
+  }
+  return {
+    table: {
+      headerRows: 1,
+      widths: ["auto", "*", "*", "*", "*", "*"],
+      body: [headerRow, ...dataRows]
+    }
+  };
+}
+
+// src/generators/rmr-generator.ts
+import { RiskMatrixConfigSchema } from "@pactosigna/schemas";
+import { readFileSync as readFileSync3, existsSync as existsSync2 } from "fs";
+import { resolve as resolve3 } from "path";
+import { parse as parseYaml2 } from "yaml";
+var HEADER_GRAY3 = "#F0F0F0";
+function isHazard(doc) {
+  return doc.frontmatter.id.startsWith("HAZ-");
+}
+function isRiskEntry(doc) {
+  return doc.frontmatter.id.startsWith("RISK-");
+}
+function loadRiskMatrix(rootDir) {
+  const candidates = [
+    resolve3(rootDir, "risk-matrix.yaml"),
+    resolve3(rootDir, "docs/risk/risk-matrix.yaml")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync2(candidate)) {
+      const raw = readFileSync3(candidate, "utf-8");
+      const parsed = parseYaml2(raw);
+      const result = RiskMatrixConfigSchema.safeParse(parsed);
+      if (result.success) {
+        return result.data;
+      }
+      console.warn(
+        `RMR: risk-matrix.yaml at ${candidate} failed validation: ${result.error.message}`
+      );
+    }
+  }
+  return null;
+}
+function getHarmSeverity(harmId, harmsById, harmOverride) {
+  if (harmOverride != null) {
+    return harmOverride;
+  }
+  const harmDoc = harmsById.get(harmId);
+  if (harmDoc && typeof harmDoc.frontmatter.severity === "number") {
+    return harmDoc.frontmatter.severity;
+  }
+  return 0;
+}
+function incrementCount(counts, key) {
+  counts.set(key, (counts.get(key) ?? 0) + 1);
+}
+function getAssessments(doc) {
+  const raw = doc.frontmatter.hazardous_situation_assessments;
+  if (!Array.isArray(raw)) return [];
+  return raw;
+}
+function isSecurityRisk(doc) {
+  return doc.frontmatter.id.startsWith("RISK-SEC-");
+}
+function buildRiskGraph(rootDir) {
+  const hazardCategories = readDocuments(rootDir, "docs/risk/hazard-categories");
+  const situations = readDocuments(rootDir, "docs/risk/situations");
+  const harms = readDocuments(rootDir, "docs/risk/harms");
+  const softwareRiskDocs = readDocuments(rootDir, "docs/software/risks");
+  const cybersecurityRiskDocs = readDocuments(rootDir, "docs/cybersecurity/risks");
+  const usabilityRiskDocs = readDocuments(rootDir, "docs/usability/risks");
+  const allSharedDocs = [...softwareRiskDocs, ...cybersecurityRiskDocs, ...usabilityRiskDocs];
+  const hazards = allSharedDocs.filter(isHazard);
+  const riskEntries = allSharedDocs.filter(isRiskEntry);
+  const matrixConfig = loadRiskMatrix(rootDir);
+  if (!matrixConfig) {
+    throw new Error(
+      "RMR: risk-matrix.yaml not found or invalid \u2014 cannot generate Risk Management Report. Place a valid risk-matrix.yaml at the repo root or docs/risk/risk-matrix.yaml."
+    );
+  }
+  const harmsById = new Map(harms.map((h) => [h.frontmatter.id, h]));
+  const inherentCounts = /* @__PURE__ */ new Map();
+  const residualCounts = /* @__PURE__ */ new Map();
+  for (const entry of riskEntries) {
+    const assessments = getAssessments(entry);
+    const useExploitability = isSecurityRisk(entry);
+    for (const assessment of assessments) {
+      const harmList = assessment.harms ?? [];
+      for (const harmEntry of harmList) {
+        const severity = getHarmSeverity(
+          harmEntry.harm,
+          harmsById,
+          harmEntry.harm_severity_override
+        );
+        if (severity === 0) continue;
+        const inherentP = useExploitability ? harmEntry.inherent_exploitability ?? 0 : harmEntry.inherent_probability ?? 0;
+        const residualP = useExploitability ? harmEntry.residual_exploitability ?? 0 : harmEntry.residual_probability ?? 0;
+        if (inherentP > 0) {
+          incrementCount(inherentCounts, `${inherentP},${severity}`);
+        }
+        if (residualP > 0) {
+          incrementCount(residualCounts, `${residualP},${severity}`);
+        }
+      }
+    }
+  }
+  return {
+    hazardCategories,
+    hazards,
+    situations,
+    harms,
+    riskEntries,
+    matrixConfig,
+    inherentCounts,
+    residualCounts
+  };
+}
+function buildRiskSummaryTable(graph) {
+  const totalRisks = graph.riskEntries.length;
+  let acceptableCount = 0;
+  let unacceptableCount = 0;
+  for (const entry of graph.riskEntries) {
+    const assessments = getAssessments(entry);
+    let entryAcceptable = true;
+    for (const assessment of assessments) {
+      for (const harm of assessment.harms ?? []) {
+        if (harm.risk_acceptable === false) {
+          entryAcceptable = false;
+        }
+      }
+    }
+    if (entryAcceptable) {
+      acceptableCount++;
+    } else {
+      unacceptableCount++;
+    }
+  }
+  return {
+    table: {
+      headerRows: 1,
+      widths: ["*", "auto"],
+      body: [
+        [
+          { text: "Metric", bold: true, fillColor: HEADER_GRAY3 },
+          { text: "Count", bold: true, fillColor: HEADER_GRAY3 }
+        ],
+        ["Total Risk Entries", String(totalRisks)],
+        ["Acceptable", String(acceptableCount)],
+        ["Unacceptable", String(unacceptableCount)],
+        ["Hazards Analyzed", String(graph.hazards.length)],
+        ["Hazardous Situations", String(graph.situations.length)],
+        ["Identified Harms", String(graph.harms.length)]
+      ]
+    },
+    layout: "lightHorizontalLines"
+  };
+}
+function buildRiskEntrySection(entry, hazardsById) {
+  const items = [];
+  items.push({
+    text: `${entry.frontmatter.id}: ${entry.frontmatter.title}`,
+    style: "h3",
+    margin: [0, 10, 0, 4]
+  });
+  const analyzedHazardId = entry.frontmatter.analyzes;
+  if (analyzedHazardId) {
+    const hazard = hazardsById.get(analyzedHazardId);
+    const hazardLabel = hazard ? `${hazard.frontmatter.id}: ${hazard.frontmatter.title}` : analyzedHazardId;
+    items.push({
+      text: [{ text: "Analyzes: ", bold: true }, hazardLabel],
+      margin: [0, 0, 0, 4]
+    });
+  }
+  const assessments = getAssessments(entry);
+  for (const assessment of assessments) {
+    items.push({
+      text: [{ text: "Hazardous Situation: ", bold: true }, assessment.hazardous_situation],
+      margin: [0, 4, 0, 2]
+    });
+    const mitigations = assessment.mitigations;
+    if (mitigations && mitigations.length > 0) {
+      items.push({
+        ul: mitigations.map((m) => ({
+          text: `${m.control} (${m.iso_category ?? "unspecified"}, reduces: ${m.reduces ?? "unspecified"})`,
+          margin: [0, 1, 0, 1]
+        }))
+      });
+    }
+    for (const harm of assessment.harms ?? []) {
+      const useExploitability = isSecurityRisk(entry);
+      const inherentLabel = useExploitability ? "exploitability" : "probability";
+      const inherentVal = useExploitability ? harm.inherent_exploitability ?? "\u2014" : harm.inherent_probability ?? "\u2014";
+      const residualVal = useExploitability ? harm.residual_exploitability ?? "\u2014" : harm.residual_probability ?? "\u2014";
+      items.push({
+        text: [
+          { text: `  Harm: ${harm.harm}`, bold: true },
+          ` \u2014 inherent ${inherentLabel}: ${inherentVal}, residual ${inherentLabel}: ${residualVal}`
+        ],
+        margin: [10, 1, 0, 1]
+      });
+    }
+  }
+  return items;
+}
+function generateRmr(input) {
+  let graph;
+  try {
+    graph = buildRiskGraph(input.rootDir);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : error);
+    return null;
+  }
+  if (graph.riskEntries.length === 0) {
+    console.warn("RMR: no approved/effective risk entry documents found \u2014 skipping");
+    return null;
+  }
+  const content = [];
+  content.push({
+    text: "Risk Summary",
+    style: "h2",
+    margin: [0, 0, 0, 10]
+  });
+  content.push(buildRiskSummaryTable(graph));
+  content.push({
+    text: "Inherent Risk Matrix",
+    style: "h2",
+    margin: [0, 20, 0, 10]
+  });
+  content.push(buildRiskMatrixTable(graph.matrixConfig, graph.inherentCounts, "probability"));
+  content.push({
+    text: "Residual Risk Matrix",
+    style: "h2",
+    margin: [0, 20, 0, 10]
+  });
+  content.push(buildRiskMatrixTable(graph.matrixConfig, graph.residualCounts, "probability"));
+  content.push({
+    text: "Individual Risk Entries",
+    style: "h2",
+    margin: [0, 20, 0, 10]
+  });
+  const hazardsById = new Map(graph.hazards.map((h) => [h.frontmatter.id, h]));
+  for (const entry of graph.riskEntries) {
+    content.push(...buildRiskEntrySection(entry, hazardsById));
+  }
+  return buildDocumentDefinition({
+    config: input.config,
+    recordTitle: "Risk Management Report",
+    recordId: "RMR",
+    version: input.version,
+    date: input.date,
+    revisionHistory: input.revisionHistory,
+    content
+  });
+}
+
+// src/github/changelog.ts
+import { execFileSync } from "child_process";
+import { resolve as resolve4 } from "path";
+import { readFileSync as readFileSync4 } from "fs";
+import matter2 from "gray-matter";
+function buildChangelog(rootDir, version, date) {
+  let previousTag = null;
+  try {
+    const output = execFileSync(
+      "gh",
+      ["release", "list", "--json", "tagName,isDraft", "--limit", "20"],
+      { encoding: "utf-8", cwd: rootDir }
+    );
+    const releases = JSON.parse(output);
+    const published = releases.filter((r) => !r.isDraft);
+    if (published.length > 0) {
+      previousTag = published[0].tagName;
+    }
+  } catch {
+  }
+  if (!previousTag) {
+    return [{ revision: version, date, description: "Initial release" }];
+  }
+  let changedFiles = [];
+  try {
+    const diff = execFileSync(
+      "git",
+      ["diff", "--name-only", `${previousTag}..HEAD`, "--", "docs/"],
+      { encoding: "utf-8", cwd: rootDir }
+    );
+    changedFiles = diff.trim().split("\n").filter(Boolean);
+  } catch {
+    return [{ revision: version, date, description: "Changes since " + previousTag }];
+  }
+  const descriptions = [];
+  for (const file of changedFiles.slice(0, 20)) {
+    try {
+      const raw = readFileSync4(resolve4(rootDir, file), "utf-8");
+      const { data } = matter2(raw);
+      if (data.id && data.title) {
+        descriptions.push(`${data.id}: ${data.title}`);
+      }
+    } catch {
+    }
+  }
+  const description = descriptions.length > 0 ? descriptions.join(", ") : `Changes since ${previousTag}`;
+  return [{ revision: version, date, description }];
+}
+
+// src/generate.ts
+var PdfPrinter = "default" in PdfPrinterModule ? PdfPrinterModule.default : PdfPrinterModule;
+var RECORD_GENERATORS = [
+  { name: "URS-User-Requirements-Specification", fn: generateUrs },
+  { name: "PRS-Product-Requirements-Specification", fn: generatePrs },
+  { name: "SRS-Software-Requirements-Specification", fn: generateSrs },
+  { name: "PTA-Product-Traceability-Analysis", fn: generatePta },
+  { name: "RMR-Risk-Management-Report", fn: generateRmr }
+];
+var noopUrlResolver = {
+  resolve: () => {
+  },
+  resolved: () => Promise.resolve()
+};
+async function renderPdf(printer, docDef) {
+  const pdfDoc = await printer.createPdfKitDocument(docDef);
+  return new Promise((done, reject) => {
+    const chunks = [];
+    pdfDoc.on("data", (chunk) => chunks.push(chunk));
+    pdfDoc.on("end", () => done(Buffer.concat(chunks)));
+    pdfDoc.on("error", reject);
+    pdfDoc.end();
+  });
+}
+async function generate(options) {
+  const config = loadConfig(options.rootDir);
+  const outDir = options.outputDir ?? pathResolve(options.rootDir, "out");
+  mkdirSync(outDir, { recursive: true });
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const revisionHistory = buildChangelog(options.rootDir, options.version, date);
+  const fonts = {
+    Helvetica: {
+      normal: "Helvetica",
+      bold: "Helvetica-Bold",
+      italics: "Helvetica-Oblique",
+      bolditalics: "Helvetica-BoldOblique"
+    },
+    Courier: {
+      normal: "Courier",
+      bold: "Courier-Bold",
+      italics: "Courier-Oblique",
+      bolditalics: "Courier-BoldOblique"
+    }
+  };
+  const printer = new PdfPrinter(fonts, void 0, noopUrlResolver);
+  const input = {
+    rootDir: options.rootDir,
+    version: options.version,
+    date,
+    config,
+    revisionHistory
+  };
+  const generated = [];
+  for (const { name, fn } of RECORD_GENERATORS) {
+    const docDef = fn(input);
+    if (!docDef) continue;
+    const buffer = await renderPdf(printer, docDef);
+    const filePath = pathResolve(outDir, `${name}.pdf`);
+    writeFileSync(filePath, buffer);
+    console.log(`Generated: ${name}.pdf`);
+    generated.push(filePath);
+  }
+  return generated;
+}
+export {
+  RecordsConfigSchema,
+  buildRiskGraph,
+  buildTraceabilityMatrix,
+  generate,
+  generatePrs,
+  generatePta,
+  generateRmr,
+  generateSrs,
+  generateUrs,
+  loadConfig
+};