@xenonbyte/da-vinci-workflow 0.1.22 → 0.1.23

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## v0.1.23 - 2026-03-29
+
+### Added
+- `lib/audit-parsers.js` to isolate markdown/checkpoint/context-delta/design-supervisor parsing concerns from audit orchestration
+- `lib/fs-safety.js` for bounded recursive traversal and project-root path-boundary checks
+- `lib/icon-text.js` to share icon text normalization/tokenization across icon modules
+- `scripts/test-audit-safety.js` to cover out-of-root registry paths and traversal truncation warnings
+- `test:audit-safety` npm script
+
+### Changed
+- `lib/audit.js` now uses bounded safe scans, emits traversal warnings, and rejects out-of-root registry `.pen` references
+- `lib/install.js` now uses bounded safe traversal for asset enumeration
+- `lib/pencil-preflight.js` now hardens VM execution with unsafe-source checks, disabled dynamic code generation, source-size limits, and explicit timeout classification
+- `lib/icon-search.js` and `lib/icon-aliases.js` now consume shared text utilities instead of duplicate local implementations
+- preflight/icon tests now include safety and normalization regression coverage
+
 ## v0.1.22 - 2026-03-29
 
 ### Added

package/README.md

@@ -28,10 +28,15 @@ This workflow is intended for:
 
 Latest published npm package:
 
-- `@xenonbyte/da-vinci-workflow@0.1.21`
+- `@xenonbyte/da-vinci-workflow@0.1.23`
 
 Release highlights:
 
+- audit parser logic is now split into `lib/audit-parsers.js`, reducing `lib/audit.js` size and making maintenance safer
+- recursive file traversal now uses bounded safe scans with depth/count limits and symlink skipping
+- completion/integrity audit now rejects out-of-root `.pen` references from `design-registry.md`
+- `preflight-pencil` sandbox now blocks unsafe runtime tokens, disables dynamic code generation, and reports timeout failures explicitly
+- icon text normalization/tokenization is now shared across `icon-search` and `icon-aliases`, removing duplicated logic and adding parity coverage
 - `da-vinci pencil-session end` now requires live snapshot input (`--nodes-file`) unless `--force` is used, preventing silent session close while live MCP and disk are out of sync
 - `build` route discipline now treats compile success as non-terminal and requires `da-vinci audit --mode completion --change <change-id> <project-path>` before reporting terminal completion
 - `continue` route guidance now blocks `build` recommendation whenever core design gates remain unresolved (missing project-local `.pen`, active session, runtime/design-source BLOCK, or required design-supervisor BLOCK)

package/README.zh-CN.md

@@ -30,10 +30,15 @@ Da Vinci 是一个把产品需求一路推进到结构化规格、Pencil 设计
 
 最新已发布 npm 包：
 
-- `@xenonbyte/da-vinci-workflow@0.1.21`
+- `@xenonbyte/da-vinci-workflow@0.1.23`
 
 已发布版本重点：
 
+- audit 解析职责已拆分到 `lib/audit-parsers.js`，`lib/audit.js` 体量下降，可维护性更好
+- 递归文件扫描改为安全有界遍历：增加深度/数量上限，并跳过符号链接
+- completion/integrity audit 现在会拦截并忽略 `design-registry.md` 中越出项目根目录的 `.pen` 引用
+- `preflight-pencil` 沙箱增强：拦截危险运行时 token、禁用动态代码生成，并对超时失败给出明确分类
+- `icon-search` 与 `icon-aliases` 现在复用同一套文本归一化/分词逻辑，去掉重复实现并补了一致性回归测试
 - `da-vinci pencil-session end` 现在默认要求提供 live 快照输入（`--nodes-file`）；只有显式 `--force` 才允许跳过，避免 live MCP 与磁盘未同步时被静默关闭
 - `build` 路由现在明确：编译成功不等于流程完成；对外宣布终态前必须通过 `da-vinci audit --mode completion --change <change-id> <project-path>`
 - `continue` 的推荐规则现在会拦截未过设计门禁时的 `build` 选路（缺少项目内 `.pen`、session 未关闭、runtime/design-source BLOCK、required design-supervisor BLOCK）

package/lib/audit-parsers.js

@@ -0,0 +1,452 @@
+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 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 isDesignSupervisorReviewRequired(daVinciText) {
+  return getVisualAssistFieldValues(daVinciText, "Require Supervisor Review").some((value) =>
+    /^true$/i.test(String(value).trim())
+  );
+}
+
+function inspectDesignSupervisorReview(pencilDesignText) {
+  const section = getMarkdownSection(pencilDesignText, "Design-Supervisor Review");
+  if (!section) {
+    return {
+      found: false,
+      status: null,
+      acceptedWarn: false,
+      hasIssueList: false,
+      hasRevisionOutcome: false
+    };
+  }
+
+  const statusMatch = section.match(/(?:^|\n)\s*-\s*(?:Status|状态)\s*:\s*(PASS|WARN|BLOCK)\b/i);
+  const status = statusMatch ? statusMatch[1].toUpperCase() : null;
+  const issueListMatch = section.match(/(?:^|\n)\s*-\s*(?:Issue list|问题列表)\s*:\s*(.+)$/im);
+  const revisionOutcomeMatch = section.match(
+    /(?:^|\n)\s*-\s*(?:Revision outcome|修订结果)\s*:\s*(.+)$/im
+  );
+  const revisionOutcome = revisionOutcomeMatch ? revisionOutcomeMatch[1].trim() : "";
+  const acceptedWarn =
+    status === "WARN" &&
+    /(accepted|accepted with follow-up|accepted warning|warn accepted|接受|已接受|接受警告)/i.test(
+      revisionOutcome
+    );
+
+  return {
+    found: true,
+    status,
+    acceptedWarn,
+    hasIssueList: Boolean(issueListMatch && issueListMatch[1].trim()),
+    hasRevisionOutcome: Boolean(revisionOutcome)
+  };
+}
+
+module.exports = {
+  normalizeCheckpointLabel,
+  parseCheckpointStatusMap,
+  hasContextDeltaExpectationSignals,
+  parseSupersedesTokens,
+  buildContextDeltaReferenceIndex,
+  resolveSupersedesReferenceIndices,
+  inspectContextDelta,
+  hasConfiguredDesignSupervisorReview,
+  isDesignSupervisorReviewRequired,
+  inspectDesignSupervisorReview
+};