@shanyucoder/flowgrid 0.1.0

package/engines/spec/lib/audit-flow-gaps.mjs

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+
+/**
+ * audit-flow-gaps.mjs
+ * Zero-dependency static audit script for FlowGrid Business Process markdown files (FLOW-*.md).
+ * Ensures 100% adherence to the 6-section business process standard and background logic rules.
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+function auditFlowContent(rawText, filePath) {
+  const gaps = [];
+
+  function addGap(code, severity, fieldPath, message, suggestedFix) {
+    gaps.push({
+      code,
+      severity, // 'critical' | 'warning' | 'info'
+      path: fieldPath,
+      message,
+      suggestedFix
+    });
+  }
+
+  // 1. Check Section 1: Context & Authorization Role Matrix
+  if (!rawText.includes('Role Matrix') && !rawText.includes('Authorization Matrix') && !rawText.includes('Bối cảnh')) {
+    addGap(
+      'FLOW_MISSING_ROLE_MATRIX',
+      'critical',
+      'Section_1_Role_Matrix',
+      'Missing Context & Business Authorization Matrix (Role Matrix).',
+      'Add table defining Personas/Roles, permissions, and trigger screens [W-*].'
+    );
+  } else if (!rawText.includes('[W-') && !rawText.includes('W-')) {
+    addGap(
+      'FLOW_MISSING_SCREEN_REFS',
+      'warning',
+      'Section_1_Screen_Refs',
+      'Role matrix does not specify target screen codes [W-*].',
+      'List specific screen codes [W-*] associated with each persona role.'
+    );
+  }
+
+  // 2. Check Section 2: Multi-tiered User Story Chain
+  const hasUserStories = rawText.includes('User Stories') || rawText.includes('User Story');
+  if (!hasUserStories) {
+    addGap(
+      'FLOW_MISSING_USER_STORIES',
+      'critical',
+      'Section_2_User_Stories',
+      'Missing Multi-tiered User Story Chain block.',
+      'Add Setup Story, Primary Story, System Story (if background triggers exist), and Tracking Story.'
+    );
+  } else {
+    // Check if background logic exists in the prompt/doc but System Story is missing
+    const mentionsBackground = /background|async|worker|cron|job|event|kafka|queue/i.test(rawText);
+    const hasSystemStory = /System Story/i.test(rawText);
+    if (mentionsBackground && !hasSystemStory) {
+      addGap(
+        'FLOW_MISSING_SYSTEM_STORY',
+        'critical',
+        'Section_2_System_Story',
+        'Process mentions background processing (worker/queue/job) but lacks a System Story.',
+        'Add System Story detailing autonomous system execution upon receiving background events.'
+      );
+    }
+  }
+
+  // 3. Check Section 3: Business Rules & State Lifecycle
+  if (!rawText.includes('Business Rules') && !rawText.includes('BR-')) {
+    addGap(
+      'FLOW_MISSING_BUSINESS_RULES',
+      'critical',
+      'Section_3_Business_Rules',
+      'Missing Business Rules table (BR-*) or State Transition Matrix.',
+      'Declare BR-* rules (validation, limits, security, retry policies).'
+    );
+  }
+
+  // 4. Check Section 4: Step-by-step Stage Journey Specification
+  if (!rawText.includes('Step-by-step') && !rawText.includes('Journey') && !rawText.includes('Stage')) {
+    addGap(
+      'FLOW_MISSING_JOURNEY',
+      'critical',
+      'Section_4_Journey',
+      'Missing Step-by-step Stage Journey Specification section.',
+      'Declare detailed stages: screen [W-*], input data, Handoffs, and background processing.'
+    );
+  }
+
+  // 5. Check Section 5: Traceability Matrix
+  if (!rawText.includes('Traceability') && !rawText.includes('Traceability Matrix')) {
+    addGap(
+      'FLOW_MISSING_TRACEABILITY',
+      'warning',
+      'Section_5_Traceability',
+      'Missing 1-to-1 Traceability Matrix between User Story, Screen, and Message.',
+      'Declare 1-to-1 traceability table mapping Story Step <-> Screen [W-*] <-> Diagram Message.'
+    );
+  }
+
+  // 6. Check Section 6: Sequence Diagram
+  if (!rawText.includes('sequenceDiagram') && !rawText.includes('```mermaid')) {
+    addGap(
+      'FLOW_MISSING_SEQUENCE_DIAGRAM',
+      'critical',
+      'Section_6_Sequence_Diagram',
+      'Missing Mermaid Sequence Diagram.',
+      'Draw sequenceDiagram modeling interactions between Screens [W-*], Backend Services, and Async Workers.'
+    );
+  } else {
+    // If background logic mentioned, check if rect rgb(...) background box is present in diagram
+    const mentionsBackground = /background|async|worker|cron|job|event|kafka|queue/i.test(rawText);
+    const hasRectRgb = rawText.includes('rect rgb(');
+    if (mentionsBackground && !hasRectRgb) {
+      addGap(
+        'FLOW_MISSING_DIAGRAM_BACKGROUND_BOX',
+        'warning',
+        'Section_6_Diagram_Background_Box',
+        'Sequence diagram does not highlight background processing with a `rect rgb(...)` block.',
+        'Wrap Async Worker steps inside a `rect rgb(240, 248, 255)` block in the Mermaid diagram.'
+      );
+    }
+  }
+
+  return {
+    file: filePath,
+    totalGaps: gaps.length,
+    criticalGaps: gaps.filter(g => g.severity === 'critical').length,
+    warningGaps: gaps.filter(g => g.severity === 'warning').length,
+    infoGaps: gaps.filter(g => g.severity === 'info').length,
+    gaps
+  };
+}
+
+// CLI Execution
+const args = process.argv.slice(2);
+if (args.length === 0) {
+  console.log('Usage: node engines/spec/lib/audit-flow-gaps.mjs <path-to-FLOW.md>');
+  process.exit(0);
+}
+
+const targetFile = path.resolve(process.cwd(), args[0]);
+if (!fs.existsSync(targetFile)) {
+  console.error(JSON.stringify({ error: `File not found: ${targetFile}` }));
+  process.exit(1);
+}
+
+const rawText = fs.readFileSync(targetFile, 'utf8');
+const report = auditFlowContent(rawText, targetFile);
+console.log(JSON.stringify(report, null, 2));

package/engines/spec/lib/audit-legacy-gaps.mjs

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+
+/**
+ * audit-legacy-gaps.mjs
+ * Zero-dependency static audit script for legacy adoption index (adoption-inventory.md).
+ * Ensures all requested screen (W-*) and API (API-*) IDs are mapped to existing legacy code files.
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+function auditLegacyInventory(inventoryPath, targetId) {
+  const gaps = [];
+
+  function addGap(code, severity, fieldPath, message, suggestedFix) {
+    gaps.push({
+      code,
+      severity, // 'critical' | 'warning' | 'info'
+      path: fieldPath,
+      message,
+      suggestedFix
+    });
+  }
+
+  if (!fs.existsSync(inventoryPath)) {
+    addGap(
+      'MISSING_ADOPTION_INVENTORY',
+      'critical',
+      'adoption-inventory.md',
+      'Legacy adoption index file `adoption-inventory.md` does not exist at workspace root.',
+      'Run `@flowgrid /adopt` to scan and index legacy repositories before archaeology.'
+    );
+    return {
+      file: inventoryPath,
+      totalGaps: gaps.length,
+      criticalGaps: gaps.length,
+      warningGaps: 0,
+      infoGaps: 0,
+      gaps
+    };
+  }
+
+  const rawText = fs.readFileSync(inventoryPath, 'utf8');
+
+  if (targetId) {
+    if (!rawText.includes(targetId)) {
+      addGap(
+        'UNMAPPED_LEGACY_ID',
+        'critical',
+        `adoption-inventory.md#${targetId}`,
+        `Archaeology target ID "${targetId}" is not listed in adoption-inventory.md.`,
+        `Re-run @flowgrid /adopt or manually add mapping line: "- ID: ${targetId} -> Path: path/to/legacy/file".`
+      );
+    }
+  }
+
+  return {
+    file: inventoryPath,
+    totalGaps: gaps.length,
+    criticalGaps: gaps.filter(g => g.severity === 'critical').length,
+    warningGaps: gaps.filter(g => g.severity === 'warning').length,
+    infoGaps: gaps.filter(g => g.severity === 'info').length,
+    gaps
+  };
+}
+
+// CLI Execution
+const args = process.argv.slice(2);
+const inventoryPath = path.resolve(process.cwd(), 'adoption-inventory.md');
+const targetId = args[0] || null;
+
+const report = auditLegacyInventory(inventoryPath, targetId);
+console.log(JSON.stringify(report, null, 2));

package/engines/spec/lib/audit-scenario-coverage.mjs

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+
+/**
+ * audit-scenario-coverage.mjs
+ * Verify each screen listed on a cross-flow SC has testcase coverage or explicit deferral.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { resolveTestsDocsRoot } from '../../shared/flowgrid-tests-docs.mjs';
+
+function parseFrontmatter(rawText) {
+  const fm = rawText.match(/^---\s*\n([\s\S]*?)\n---/);
+  return fm ? fm[1] : rawText;
+}
+
+function parseScreens(yamlLike) {
+  const screens = new Set();
+  const listMatch = yamlLike.match(/screens:\s*\[([^\]]+)\]/);
+  if (listMatch) {
+    for (const m of listMatch[1].matchAll(/(W-[\w-]+)/g)) {
+      screens.add(m[1]);
+    }
+  }
+  const blockMatch = yamlLike.match(/^screens:\s*$/m);
+  if (blockMatch) {
+    const tail = yamlLike.slice(blockMatch.index);
+    const lines = tail.split('\n').slice(1);
+    for (const line of lines) {
+      if (/^\S/.test(line)) break;
+      if (/^\s{0,3}\w[\w-]*:\s*/.test(line) && !/^\s*-\s/.test(line)) break;
+      for (const m of line.matchAll(/(W-[\w-]+)/g)) {
+        screens.add(m[1]);
+      }
+    }
+  }
+  const single = yamlLike.match(/^\s*screen:\s*(W-[\w-]+)/m);
+  if (single) screens.add(single[1]);
+  return [...screens];
+}
+
+function parseDeferred(yamlLike) {
+  const deferred = new Map();
+  for (const m of yamlLike.matchAll(
+    /deferred:\s*(QA-[\w-]+)[\s\S]*?(?:screen:\s*(W-[\w-]+)|#\s*screen:\s*(W-[\w-]+))?/g,
+  )) {
+    const qa = m[1];
+    const screen = m[2] || m[3];
+    if (screen) deferred.set(screen, qa);
+  }
+  const block = yamlLike.match(/coverage_deferred:\s*\n((?:\s+-\s*.+\n)+)/);
+  if (block) {
+    for (const line of block[1].split('\n')) {
+      const pair = line.match(/screen:\s*(W-[\w-]+).*deferred:\s*(QA-[\w-]+)/);
+      if (pair) deferred.set(pair[1], pair[2]);
+      const pair2 = line.match(/deferred:\s*(QA-[\w-]+).*screen:\s*(W-[\w-]+)/);
+      if (pair2) deferred.set(pair2[2], pair2[1]);
+    }
+  }
+  return deferred;
+}
+
+function collectTcScreens(testsDocsRoot) {
+  const covered = new Set();
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const full = path.join(dir, e.name);
+      if (e.isDirectory()) {
+        if (e.name === 'node_modules' || e.name === '.git') continue;
+        walk(full);
+      } else if (/\.(ya?ml|md)$/i.test(e.name) && /TC/i.test(e.name)) {
+        try {
+          const text = fs.readFileSync(full, 'utf8');
+          for (const m of text.matchAll(/screen:\s*(W-[\w-]+)/g)) {
+            covered.add(m[1]);
+          }
+          for (const m of text.matchAll(/screen:\s*(W-[\w-]+)/g)) {
+            covered.add(m[1]);
+          }
+        } catch {
+          /* ignore */
+        }
+      }
+    }
+  };
+  walk(testsDocsRoot);
+  return covered;
+}
+
+export function auditScenarioCoverage(scText, meta = {}) {
+  const gaps = [];
+  const filePath = meta.filePath ?? '';
+  const testsDocs = meta.testsDocs ?? resolveTestsDocsRoot() ?? process.cwd();
+  const fm = parseFrontmatter(scText);
+  const screens = parseScreens(fm);
+  const deferred = parseDeferred(fm);
+  const covered = collectTcScreens(testsDocs);
+
+  function addGap(code, severity, fieldPath, message, suggestedFix) {
+    gaps.push({ code, severity, path: fieldPath, message, suggestedFix, category: 'scenario-coverage' });
+  }
+
+  if (screens.length === 0) {
+    addGap(
+      'SC_MISSING_SCREENS',
+      'critical',
+      'screens',
+      'Scenario file missing screens: [W-*] list in frontmatter.',
+      'Add screens: [W-…] for every W-* touched by this FLOW journey.',
+    );
+  }
+
+  for (const screen of screens) {
+    if (deferred.has(screen)) continue;
+    if (!covered.has(screen)) {
+      addGap(
+        'SC_SCREEN_NO_TC',
+        'warning',
+        `screens.${screen}`,
+        `No testcase under tests root references screen ${screen}.`,
+        `Add cases/**/TC-*.yaml with refs.screen: ${screen} or defer with coverage_deferred entry (QA-*).`,
+      );
+    }
+  }
+
+  return {
+    file: filePath,
+    testsDocs,
+    screens,
+    deferred: Object.fromEntries(deferred),
+    coveredScreens: [...covered].filter((s) => screens.includes(s)),
+    totalGaps: gaps.length,
+    criticalGaps: gaps.filter((g) => g.severity === 'critical').length,
+    warningGaps: gaps.filter((g) => g.severity === 'warning').length,
+    gaps,
+  };
+}
+
+function parseArgs(argv) {
+  let testsDocs = resolveTestsDocsRoot() ?? process.cwd();
+  const positional = [];
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === '--tests-docs' && argv[i + 1]) {
+      testsDocs = path.resolve(process.cwd(), argv[++i]);
+    } else {
+      positional.push(argv[i]);
+    }
+  }
+  return { scPath: positional[0], testsDocs };
+}
+
+// CLI
+const cliArgs = process.argv.slice(2);
+if (cliArgs.length === 0) {
+  console.log(
+    'Usage: node audit-scenario-coverage.mjs <SC.yaml|SC.md> [--tests-docs path] (or FLOWGRID_TESTS_DOC)',
+  );
+  process.exit(0);
+}
+
+const { scPath, testsDocs } = parseArgs(cliArgs);
+const resolved = path.resolve(process.cwd(), scPath);
+if (!fs.existsSync(resolved)) {
+  console.error(JSON.stringify({ error: `File not found: ${resolved}` }));
+  process.exit(1);
+}
+const scText = fs.readFileSync(resolved, 'utf8');
+const report = auditScenarioCoverage(scText, { filePath: resolved, testsDocs });
+console.log(JSON.stringify(report, null, 2));

package/engines/spec/lib/audit-testcase-bundle-cross.mjs

@@ -0,0 +1,145 @@
+/**
+ * Cross-reference a test plan YAML against a function *.bundle.yaml (authoring SSOT).
+ * Heuristic fallback when traceability block is incomplete.
+ */
+
+import { parseBundleTraceability as parseBundleInventory } from '../../cases/lib/parse-bundle-traceability.mjs';
+
+/** @param {string} bundleText */
+export function parseBundleTraceability(bundleText) {
+  const inv = parseBundleInventory(bundleText);
+  return {
+    scenarios: inv.scenarios.map((s) => s.name),
+    acceptance: inv.acceptance.map((a) => a.text),
+    actions: inv.actions.map((a) => a.id),
+  };
+}
+
+function normalizeKey(text) {
+  return text
+    .toLowerCase()
+    .replace(/[^\p{L}\p{N}\s]/gu, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function scenarioTokens(name) {
+  const n = normalizeKey(name);
+  const paren = name.match(/\(([^)]+)\)/);
+  const tokens = new Set();
+  if (paren) {
+    for (const part of paren[1].split(/[/,&]/)) {
+      const t = normalizeKey(part);
+      if (t.length >= 4) tokens.add(t);
+    }
+  }
+  for (const part of n.split(/\s+/)) {
+    if (part.length >= 5) tokens.add(part);
+  }
+  if (n.length >= 8) tokens.add(n.slice(0, 40));
+  return [...tokens];
+}
+
+function tcReferencesScenario(tcText, scenarioName) {
+  const normName = normalizeKey(scenarioName);
+  if (tcText.includes(scenarioName)) return true;
+  if (/scenarioRef:\s*/.test(tcText) && normName.length >= 6) {
+    const ref = tcText.match(/scenarioRef:\s*["']?([^"'\n]+)["']?/);
+    if (ref && normalizeKey(ref[1]).includes(normName.slice(0, 20))) return true;
+  }
+  const tokens = scenarioTokens(scenarioName);
+  return tokens.some((t) => t.length >= 5 && tcText.toLowerCase().includes(t));
+}
+
+function tcCoversAcceptance(tcText, acLine) {
+  const key = normalizeKey(acLine).slice(0, 48);
+  if (key.length < 8) return true;
+  if (tcText.toLowerCase().includes(key.slice(0, 24))) return true;
+  if (/verifiesAcceptance:/.test(tcText)) {
+    const block = tcText.slice(tcText.indexOf('verifiesAcceptance:'));
+    if (block.toLowerCase().includes(key.slice(0, 20))) return true;
+  }
+  return false;
+}
+
+function tcCoversAction(tcText, actionId, bundleText) {
+  if (tcText.includes(actionId)) return true;
+  if (/actionRef:\s*/.test(tcText) && tcText.includes(actionId.replace('btn_', ''))) return true;
+  const actionChunk = bundleText.match(
+    new RegExp(`id:\\s*${actionId}[\\s\\S]*?outcomes:`),
+  );
+  if (!actionChunk) return tcText.includes('success') || tcText.includes('Happy');
+  const chunk = actionChunk[0];
+  if (chunk.includes('onSuccess') && (tcText.includes('success') || tcText.includes('Happy Path'))) {
+    return true;
+  }
+  if (chunk.includes('409') && (tcText.includes('409') || tcText.includes('conflict'))) return true;
+  if (chunk.includes('422') && (tcText.includes('422') || tcText.includes('validation'))) return true;
+  if (chunk.includes('403') && (tcText.includes('403') || tcText.includes('permission'))) return true;
+  return false;
+}
+
+/**
+ * @param {string} bundleText
+ * @param {string} tcText
+ * @param {string} [bundlePath]
+ */
+export function auditTestcaseBundleCross(bundleText, tcText, bundlePath = '') {
+  const gaps = [];
+  const { scenarios, acceptance, actions } = parseBundleTraceability(bundleText);
+
+  function addGap(code, severity, fieldPath, message, suggestedFix) {
+    gaps.push({ code, severity, path: fieldPath, message, suggestedFix, category: 'bundle-cross' });
+  }
+
+  if (scenarios.length === 0 && acceptance.length === 0) {
+    addGap(
+      'TC_BUNDLE_EMPTY_TRACE',
+      'warning',
+      'bundle.userStories',
+      'Bundle has no scenarios or acceptanceCriteria to cross-check.',
+      'Complete bundle userStories on docs hub before testcase cross-audit.',
+    );
+    return { bundle: bundlePath, bundleCrossGaps: gaps };
+  }
+
+  for (const name of scenarios) {
+    if (!tcReferencesScenario(tcText, name)) {
+      addGap(
+        'TC_BUNDLE_SCENARIO_UNCOVERED',
+        'warning',
+        `userStories.scenarios.${name}`,
+        `No testcase references scenario "${name}".`,
+        'Add testcase with scenarioRef or title/steps mentioning this scenario (or parent SC E2E).',
+      );
+    }
+  }
+
+  for (const ac of acceptance) {
+    if (!tcCoversAcceptance(tcText, ac)) {
+      addGap(
+        'TC_BUNDLE_AC_UNCOVERED',
+        'info',
+        'acceptanceCriteria',
+        `Acceptance line not reflected in test plan: "${ac.length > 80 ? `${ac.slice(0, 80)}…` : ac}"`,
+        'Add verifiesAcceptance[] entry or testcase steps/assertions mapping to this AC line.',
+      );
+    }
+  }
+
+  for (const actionId of actions) {
+    const hasOutcomes = bundleText.includes(`id: ${actionId}`) && bundleText.includes('outcomes:');
+    if (!hasOutcomes) continue;
+    if (!tcCoversAction(tcText, actionId, bundleText)) {
+      addGap(
+        'TC_BUNDLE_ACTION_UNCOVERED',
+        'info',
+        `design.actions.${actionId}`,
+        `Design action "${actionId}" with outcomes matrix has no explicit testcase trace.`,
+        `Reference actionRef: ${actionId} or cover happy/422/409/403 paths in test matrix.`,
+      );
+    }
+  }
+
+  return { bundle: bundlePath, bundleCrossGaps: gaps };
+}

package/engines/spec/lib/audit-testcase-gaps.mjs

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+
+/**
+ * audit-testcase-gaps.mjs
+ * Audits cases/TC-*.yaml (v2) or legacy plan YAML.
+ * Optional --bundle cross-reference against *.bundle.yaml.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { auditTestcaseBundleCross } from './audit-testcase-bundle-cross.mjs';
+import { auditTestcasePlanContent } from './audit-testcase-plan-gaps.mjs';
+import { auditTestcaseTcFile, isTestCaseArtifact } from './audit-testcase-tc.mjs';
+
+export function auditTestcaseContent(rawText, filePath) {
+  if (isTestCaseArtifact(filePath, rawText)) {
+    return auditTestcaseTcFile(rawText, filePath);
+  }
+  const report = auditTestcasePlanContent(rawText, filePath);
+  return { ...report, artifactKind: 'plan' };
+}
+
+function parseCliArgs(argv) {
+  let bundlePath = null;
+  const positional = [];
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === '--bundle' && argv[i + 1]) {
+      bundlePath = argv[++i];
+    } else {
+      positional.push(argv[i]);
+    }
+  }
+  return { targetFile: positional[0], bundlePath };
+}
+
+function mergeBundleReport(report, bundleFile, bundleText, tcText) {
+  const cross = auditTestcaseBundleCross(bundleText, tcText, bundleFile);
+  report.bundle = cross.bundle;
+  report.bundleCrossGaps = cross.bundleCrossGaps;
+  for (const g of cross.bundleCrossGaps) {
+    report.gaps.push(g);
+  }
+  report.totalGaps = report.gaps.length;
+  report.criticalGaps = report.gaps.filter((g) => g.severity === 'critical').length;
+  report.warningGaps = report.gaps.filter((g) => g.severity === 'warning').length;
+  report.infoGaps = report.gaps.filter((g) => g.severity === 'info').length;
+  return report;
+}
+
+// CLI
+const args = process.argv.slice(2);
+if (args.length === 0) {
+  console.log(
+    'Usage: node engines/spec/lib/audit-testcase-gaps.mjs <TC-*.yaml|plan.test.yaml> [--bundle path/to/foo.bundle.yaml]',
+  );
+  process.exit(0);
+}
+
+const { targetFile: targetArg, bundlePath: bundleArg } = parseCliArgs(args);
+const targetFile = path.resolve(process.cwd(), targetArg);
+if (!fs.existsSync(targetFile)) {
+  console.error(JSON.stringify({ error: `File not found: ${targetFile}` }));
+  process.exit(1);
+}
+
+const rawText = fs.readFileSync(targetFile, 'utf8');
+let report = auditTestcaseContent(rawText, targetFile);
+
+if (bundleArg) {
+  const bundleFile = path.resolve(process.cwd(), bundleArg);
+  if (!fs.existsSync(bundleFile)) {
+    console.error(JSON.stringify({ error: `Bundle not found: ${bundleFile}` }));
+    process.exit(1);
+  }
+  const bundleText = fs.readFileSync(bundleFile, 'utf8');
+  report = mergeBundleReport(report, bundleFile, bundleText, rawText);
+}
+
+console.log(JSON.stringify(report, null, 2));