@xenonbyte/da-vinci-workflow 0.1.22 → 0.1.24

package/lib/audit-parsers.js

@@ -0,0 +1,598 @@
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function getMarkdownSection(text, heading) {
+  if (!text) {
+    return "";
+  }
+
+  const escapedHeading = escapeRegExp(heading);
+  const headingPattern = new RegExp(`^##\\s+${escapedHeading}\\s*$`, "i");
+  const anyHeadingPattern = /^##\s+/;
+  const lines = String(text).replace(/\r\n?/g, "\n").split("\n");
+  const sectionLines = [];
+  let capturing = false;
+
+  for (const line of lines) {
+    if (capturing && anyHeadingPattern.test(line)) {
+      break;
+    }
+
+    if (!capturing && headingPattern.test(line)) {
+      capturing = true;
+      continue;
+    }
+
+    if (capturing) {
+      sectionLines.push(line);
+    }
+  }
+
+  return sectionLines.join("\n").trim();
+}
+
+function getMarkdownSectionsByHeading(text, heading, options = {}) {
+  if (!text) {
+    return [];
+  }
+
+  const escapedHeading = escapeRegExp(heading);
+  const allowParentheticalSuffix = options.allowParentheticalSuffix === true;
+  const suffixPattern = allowParentheticalSuffix ? String.raw`(?:\s*\([^)\n]*\))?` : "";
+  const headingPattern = new RegExp(`^##\\s+${escapedHeading}${suffixPattern}\\s*$`, "i");
+  const anyHeadingPattern = /^##\s+/;
+  const lines = String(text).replace(/\r\n?/g, "\n").split("\n");
+  const sections = [];
+  let capturing = false;
+  let currentHeading = "";
+  let sectionLines = [];
+
+  function flushSection() {
+    if (!capturing) {
+      return;
+    }
+
+    sections.push({
+      heading: currentHeading,
+      content: sectionLines.join("\n").trim()
+    });
+    capturing = false;
+    currentHeading = "";
+    sectionLines = [];
+  }
+
+  for (const line of lines) {
+    if (capturing && anyHeadingPattern.test(line)) {
+      flushSection();
+    }
+
+    if (!capturing && headingPattern.test(line)) {
+      capturing = true;
+      currentHeading = line.trim();
+      sectionLines = [];
+      continue;
+    }
+
+    if (capturing) {
+      sectionLines.push(line);
+    }
+  }
+
+  flushSection();
+  return sections;
+}
+
+function extractReviewFieldValue(section, fieldNames) {
+  const lines = String(section || "").replace(/\r\n?/g, "\n").split("\n");
+  const escapedFieldNames = fieldNames.map((fieldName) => escapeRegExp(fieldName)).join("|");
+  const fieldPattern = new RegExp(`^\\s*-\\s*(?:${escapedFieldNames})\\s*:\\s*(.*)$`, "i");
+  const topLevelFieldPattern = /^\s*-\s+[^:\n]+:\s*.*$/;
+  const bulletPattern = /^\s*-\s+(.+)$/;
+  const nestedTextPattern = /^\s{2,}(.+)$/;
+  const values = [];
+  let capturing = false;
+
+  for (const rawLine of lines) {
+    if (/^##\s+/.test(rawLine)) {
+      if (capturing) {
+        break;
+      }
+      continue;
+    }
+
+    const fieldMatch = rawLine.match(fieldPattern);
+    if (!capturing && fieldMatch) {
+      capturing = true;
+      const inlineValue = String(fieldMatch[1] || "").trim();
+      if (inlineValue) {
+        values.push(inlineValue);
+      }
+      continue;
+    }
+
+    if (!capturing) {
+      continue;
+    }
+
+    if (topLevelFieldPattern.test(rawLine)) {
+      break;
+    }
+
+    const bulletMatch = rawLine.match(bulletPattern);
+    if (bulletMatch) {
+      const value = String(bulletMatch[1] || "").trim();
+      if (value) {
+        values.push(value);
+      }
+      continue;
+    }
+
+    const nestedTextMatch = rawLine.match(nestedTextPattern);
+    if (nestedTextMatch) {
+      const value = String(nestedTextMatch[1] || "").trim();
+      if (value) {
+        values.push(value);
+      }
+      continue;
+    }
+
+    if (rawLine.trim() === "") {
+      continue;
+    }
+
+    break;
+  }
+
+  return values.join("\n").trim();
+}
+
+function parseListTokens(value) {
+  return String(value || "")
+    .split(/[,\n;]/)
+    .map((token) =>
+      token
+        .replace(/^[\-\*\u2022]\s*/, "")
+        .replace(/`/g, "")
+        .trim()
+    )
+    .filter(Boolean);
+}
+
+function normalizeCheckpointLabel(value) {
+  return String(value || "")
+    .toLowerCase()
+    .replace(/`/g, "")
+    .replace(/[_-]+/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function parseCheckpointStatusMap(markdownText) {
+  const section = getMarkdownSection(markdownText, "Checkpoint Status");
+  if (!section) {
+    return {};
+  }
+
+  const statuses = {};
+  const matches = section.matchAll(/(?:^|\n)\s*-\s*`?([^`:\n]+?)`?\s*:\s*(PASS|WARN|BLOCK)\b/gi);
+  for (const match of matches) {
+    const label = normalizeCheckpointLabel(match[1]);
+    if (!label) {
+      continue;
+    }
+    statuses[label] = String(match[2]).toUpperCase();
+  }
+
+  return statuses;
+}
+
+function hasContextDeltaExpectationSignals(markdownText) {
+  const text = String(markdownText || "");
+  return (
+    /##\s+(Checkpoint Status|MCP Runtime Gate)\b/i.test(text) ||
+    /(?:^|\n)\s*(?:[-*]\s*)?`?Context Delta Required`?\s*:\s*(?:true|yes|on|1)\b/i.test(text)
+  );
+}
+
+function parseSupersedesTokens(value) {
+  return String(value || "")
+    .split(/[,\n;]/)
+    .map((token) => token.trim())
+    .filter(Boolean);
+}
+
+function normalizeTimeToken(value) {
+  const raw = String(value || "").trim();
+  if (!raw) {
+    return "";
+  }
+
+  const parseCandidates = [];
+  const rawWithT = raw.includes(" ") ? raw.replace(/\s+/, "T") : raw;
+  const hasExplicitTimezone = /(?:Z|[+-]\d{2}:?\d{2})$/i.test(rawWithT);
+
+  if (!hasExplicitTimezone && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/.test(rawWithT)) {
+    parseCandidates.push(`${rawWithT}Z`);
+  }
+
+  parseCandidates.push(rawWithT);
+  parseCandidates.push(raw);
+
+  for (const candidate of parseCandidates) {
+    const timestamp = Date.parse(candidate);
+    if (!Number.isFinite(timestamp)) {
+      continue;
+    }
+    return new Date(timestamp).toISOString();
+  }
+
+  return "";
+}
+
+function getTimeReferenceKeys(value) {
+  const raw = String(value || "").trim();
+  if (!raw) {
+    return [];
+  }
+
+  const keys = new Set([raw]);
+
+  if (raw.includes(" ")) {
+    keys.add(raw.replace(/\s+/, "T"));
+  }
+
+  if (raw.endsWith(".000Z")) {
+    keys.add(raw.replace(".000Z", "Z"));
+  }
+
+  const normalized = normalizeTimeToken(raw);
+  if (normalized) {
+    keys.add(normalized);
+    if (normalized.endsWith(".000Z")) {
+      keys.add(normalized.replace(".000Z", "Z"));
+    }
+  }
+
+  return [...keys];
+}
+
+function buildContextDeltaReferenceIndex(entries) {
+  const referenceIndex = new Map();
+
+  function addReference(key, entryIndex) {
+    const normalizedKey = String(key || "").trim();
+    if (!normalizedKey) {
+      return;
+    }
+
+    const existing = referenceIndex.get(normalizedKey) || [];
+    existing.push(entryIndex);
+    referenceIndex.set(normalizedKey, existing);
+  }
+
+  entries.forEach((entry, entryIndex) => {
+    if (entry.time) {
+      for (const timeKey of getTimeReferenceKeys(entry.time)) {
+        addReference(timeKey, entryIndex);
+        addReference(`time:${timeKey}`, entryIndex);
+      }
+    }
+
+    if (entry.checkpointType && entry.time) {
+      const normalizedCheckpointType = normalizeCheckpointLabel(entry.checkpointType);
+      for (const timeKey of getTimeReferenceKeys(entry.time)) {
+        addReference(`${entry.checkpointType}@${timeKey}`, entryIndex);
+        addReference(`${normalizedCheckpointType}@${timeKey}`, entryIndex);
+      }
+    }
+  });
+
+  return referenceIndex;
+}
+
+function getSupersedesCandidateKeys(token) {
+  const trimmed = String(token || "").trim();
+  if (!trimmed) {
+    return [];
+  }
+
+  const keys = new Set([trimmed]);
+  const prefixedTimeMatch = trimmed.match(/^time\s*:\s*(.+)$/i);
+  if (prefixedTimeMatch) {
+    for (const timeKey of getTimeReferenceKeys(prefixedTimeMatch[1])) {
+      keys.add(timeKey);
+      keys.add(`time:${timeKey}`);
+    }
+  } else {
+    keys.add(`time:${trimmed}`);
+    for (const timeKey of getTimeReferenceKeys(trimmed)) {
+      keys.add(timeKey);
+      keys.add(`time:${timeKey}`);
+    }
+  }
+
+  const atIndex = trimmed.indexOf("@");
+  if (atIndex > 0 && atIndex < trimmed.length - 1) {
+    const checkpointType = trimmed.slice(0, atIndex).trim();
+    const time = trimmed.slice(atIndex + 1).trim();
+    if (checkpointType && time) {
+      const normalizedCheckpointType = normalizeCheckpointLabel(checkpointType);
+      for (const timeKey of getTimeReferenceKeys(time)) {
+        keys.add(`${checkpointType}@${timeKey}`);
+        keys.add(`${normalizedCheckpointType}@${timeKey}`);
+      }
+    }
+  }
+
+  return [...keys];
+}
+
+function resolveSupersedesReferenceIndices(token, referenceIndex) {
+  const indices = new Set();
+  for (const key of getSupersedesCandidateKeys(token)) {
+    const matches = referenceIndex.get(key);
+    if (!matches) {
+      continue;
+    }
+    for (const entryIndex of matches) {
+      indices.add(entryIndex);
+    }
+  }
+  return [...indices].sort((a, b) => a - b);
+}
+
+function inspectContextDelta(markdownText) {
+  const section = getMarkdownSection(markdownText, "Context Delta");
+  if (!section) {
+    return {
+      found: false,
+      hasConcreteEntry: false,
+      entries: [],
+      incompleteEntryCount: 0
+    };
+  }
+
+  const lines = String(section).replace(/\r\n?/g, "\n").split("\n");
+  const entries = [];
+  let current = null;
+
+  function ensureCurrent() {
+    if (!current) {
+      current = {};
+    }
+  }
+
+  function flushCurrent() {
+    if (!current) {
+      return;
+    }
+
+    const hasAnyValue = [
+      current.time,
+      current.checkpointType,
+      current.goal,
+      current.decision,
+      current.constraints,
+      current.impact,
+      current.status,
+      current.nextAction,
+      current.supersedes
+    ].some((value) => Boolean(value));
+
+    if (hasAnyValue) {
+      entries.push(current);
+    }
+    current = null;
+  }
+
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+
+    if (!line) {
+      continue;
+    }
+
+    const timeMatch = line.match(/^-+\s*`?time`?\s*:\s*(.+)$/i);
+    if (timeMatch) {
+      flushCurrent();
+      current = {
+        time: timeMatch[1].trim()
+      };
+      continue;
+    }
+
+    const checkpointTypeMatch = line.match(/^-+\s*`?checkpoint(?:[_ -]?type)?`?\s*:\s*(.+)$/i);
+    if (checkpointTypeMatch) {
+      ensureCurrent();
+      current.checkpointType = checkpointTypeMatch[1].trim();
+      continue;
+    }
+
+    const goalMatch = line.match(/^-+\s*`?goal`?\s*:\s*(.+)$/i);
+    if (goalMatch) {
+      ensureCurrent();
+      current.goal = goalMatch[1].trim();
+      continue;
+    }
+
+    const decisionMatch = line.match(/^-+\s*`?decision`?\s*:\s*(.+)$/i);
+    if (decisionMatch) {
+      ensureCurrent();
+      current.decision = decisionMatch[1].trim();
+      continue;
+    }
+
+    const constraintsMatch = line.match(/^-+\s*`?constraints`?\s*:\s*(.+)$/i);
+    if (constraintsMatch) {
+      ensureCurrent();
+      current.constraints = constraintsMatch[1].trim();
+      continue;
+    }
+
+    const impactMatch = line.match(/^-+\s*`?impact`?\s*:\s*(.+)$/i);
+    if (impactMatch) {
+      ensureCurrent();
+      current.impact = impactMatch[1].trim();
+      continue;
+    }
+
+    const statusMatch = line.match(/^-+\s*`?status`?\s*:\s*(PASS|WARN|BLOCK)\b/i);
+    if (statusMatch) {
+      ensureCurrent();
+      current.status = String(statusMatch[1]).toUpperCase();
+      continue;
+    }
+
+    const nextActionMatch = line.match(/^-+\s*`?next(?:[_ -]?action)?`?\s*:\s*(.+)$/i);
+    if (nextActionMatch) {
+      ensureCurrent();
+      current.nextAction = nextActionMatch[1].trim();
+      continue;
+    }
+
+    const supersedesMatch = line.match(/^-+\s*`?supersedes`?\s*:\s*(.+)$/i);
+    if (supersedesMatch) {
+      ensureCurrent();
+      current.supersedes = supersedesMatch[1].trim();
+      continue;
+    }
+  }
+
+  flushCurrent();
+
+  const hasConcreteEntry = entries.some(
+    (entry) => entry.time || entry.checkpointType || entry.status || entry.decision || entry.nextAction
+  );
+  const incompleteEntryCount = entries.filter(
+    (entry) => !entry.time || !entry.checkpointType || !entry.status
+  ).length;
+
+  return {
+    found: true,
+    hasConcreteEntry,
+    entries,
+    incompleteEntryCount
+  };
+}
+
+function getVisualAssistFieldValues(daVinciText, fieldName) {
+  const section = getMarkdownSection(daVinciText, "Visual Assist");
+  if (!section) {
+    return [];
+  }
+
+  const fieldPattern = new RegExp(`^\\s*-\\s*${escapeRegExp(fieldName)}\\s*:\\s*(.*)$`, "i");
+  const nestedValuePattern = /^\s{2,}-\s*(.+?)\s*$/;
+  const nextFieldPattern = /^\s*-\s+[^:]+:\s*.*$/;
+  const values = [];
+  let capturing = false;
+
+  for (const rawLine of String(section).replace(/\r\n?/g, "\n").split("\n")) {
+    const fieldMatch = rawLine.match(fieldPattern);
+    if (!capturing && fieldMatch) {
+      capturing = true;
+      const inlineValue = (fieldMatch[1] || "").trim();
+      if (inlineValue) {
+        values.push(inlineValue);
+      }
+      continue;
+    }
+
+    if (capturing && nextFieldPattern.test(rawLine)) {
+      break;
+    }
+
+    if (capturing) {
+      const nestedMatch = rawLine.match(nestedValuePattern);
+      if (nestedMatch) {
+        const value = nestedMatch[1].trim();
+        if (value) {
+          values.push(value);
+        }
+      } else if (rawLine.trim() === "") {
+        continue;
+      } else {
+        break;
+      }
+    }
+  }
+
+  return values;
+}
+
+function hasConfiguredDesignSupervisorReview(daVinciText) {
+  return getVisualAssistFieldValues(daVinciText, "Design-supervisor reviewers").length > 0;
+}
+
+function getConfiguredDesignSupervisorReviewers(daVinciText) {
+  return getVisualAssistFieldValues(daVinciText, "Design-supervisor reviewers")
+    .flatMap((value) => parseListTokens(value))
+    .filter(Boolean);
+}
+
+function isDesignSupervisorReviewRequired(daVinciText) {
+  return getVisualAssistFieldValues(daVinciText, "Require Supervisor Review").some((value) =>
+    /^true$/i.test(String(value).trim())
+  );
+}
+
+function inspectDesignSupervisorReview(pencilDesignText) {
+  const sections = getMarkdownSectionsByHeading(pencilDesignText, "Design-Supervisor Review", {
+    allowParentheticalSuffix: true
+  });
+  if (sections.length === 0) {
+    return {
+      found: false,
+      status: null,
+      acceptedWarn: false,
+      hasIssueList: false,
+      hasRevisionOutcome: false
+    };
+  }
+
+  const section = sections[sections.length - 1].content;
+  const statusMatch = section.match(
+    /(?:^|\n)\s*-\s*(?:Status|状态|Result|结果)\s*:\s*`?(PASS|WARN|BLOCK)`?\b/i
+  );
+  const status = statusMatch ? statusMatch[1].toUpperCase() : null;
+  const issueList = extractReviewFieldValue(section, ["Issue list", "问题列表"]);
+  const revisionOutcome = extractReviewFieldValue(section, ["Revision outcome", "修订结果"]);
+  const configuredReviewersRaw = extractReviewFieldValue(section, ["Configured reviewers", "配置评审"]);
+  const executedReviewersRaw = extractReviewFieldValue(section, ["Executed reviewers", "Executed reviewer skills", "执行评审"]);
+  const reviewSource = extractReviewFieldValue(section, ["Review source", "评审来源"]).toLowerCase();
+  const acceptedWarn =
+    status === "WARN" &&
+    /(accepted|accepted with follow-up|accepted warning|warn accepted|接受|已接受|接受警告)/i.test(
+      revisionOutcome
+    );
+  const configuredReviewers = parseListTokens(configuredReviewersRaw);
+  const executedReviewers = parseListTokens(executedReviewersRaw);
+
+  return {
+    found: true,
+    status,
+    acceptedWarn,
+    hasIssueList: Boolean(issueList),
+    hasRevisionOutcome: Boolean(revisionOutcome),
+    configuredReviewers,
+    executedReviewers,
+    reviewSource,
+    hasConfiguredReviewers: configuredReviewers.length > 0,
+    hasExecutedReviewers: executedReviewers.length > 0
+  };
+}
+
+module.exports = {
+  normalizeCheckpointLabel,
+  parseCheckpointStatusMap,
+  hasContextDeltaExpectationSignals,
+  parseSupersedesTokens,
+  buildContextDeltaReferenceIndex,
+  resolveSupersedesReferenceIndices,
+  inspectContextDelta,
+  getConfiguredDesignSupervisorReviewers,
+  hasConfiguredDesignSupervisorReview,
+  isDesignSupervisorReviewRequired,
+  inspectDesignSupervisorReview
+};