@skill-graph/cli 0.5.6

package/scripts/lint/check-archetype-sections.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+/**
+ * Archetype-aware section validator for SKILL.md files.
+ *
+ * Each archetype has a minimum required set of H2 body sections defined in
+ * `docs/skill-metadata-protocol.md § Archetype Section Map`. This check:
+ *
+ *   - Errors on any required H2 section that is missing from the body.
+ *   - Warns on any H2 section that exists but whose content is empty
+ *     (< 50 non-whitespace characters between consecutive H2 headers).
+ *
+ * The warning threshold (50 chars) catches placeholder sections like
+ * `## Verification\n\n(todo)\n` without tripping on intentionally terse
+ * but real sections such as a two-bullet `## Do NOT Use When` list.
+ *
+ * @module lint/check-archetype-sections
+ */
+
+'use strict';
+
+/**
+ * Required H2 sections per archetype, sourced from
+ * `docs/skill-metadata-protocol.md § Archetype Section Map`.
+ *
+ * @type {Record<string, string[]>}
+ */
+const REQUIRED_SECTIONS = {
+  capability: ['Coverage', 'Philosophy', 'Verification', 'Do NOT Use When'],
+  workflow:   ['Coverage', 'Philosophy', 'Workflow', 'Verification', 'Do NOT Use When'],
+  router:     ['Coverage', 'Routing Rules', 'Do NOT Use When'],
+  overlay:    ['Coverage', 'Overlay Rules', 'Extends', 'Do NOT Use When'],
+};
+
+/**
+ * Conditional section requirements. Applied on top of REQUIRED_SECTIONS based on
+ * frontmatter values. Each entry is `{ section, predicate, help }` — if the
+ * predicate returns true for the frontmatter, the section is required in
+ * addition to the archetype's base set.
+ *
+ * The `## Evals` rule closes a discoverability gap: a skill that declares
+ * `eval_artifacts: present` but has no `## Evals` body section hides the eval
+ * surface from readers (the artifact is findable only via the `examples/evals/`
+ * scan). Forcing the section guarantees the skill body links to its eval file.
+ */
+const CONDITIONAL_SECTIONS = [
+  {
+    section:   'Evals',
+    predicate: (fm) => fm && fm.eval_artifacts === 'present',
+    help:      'Add a "## Evals" body section that references the eval artifact under examples/evals/ so readers can discover it from the SKILL.md alone.',
+  },
+];
+
+/**
+ * Extract all top-level H2 section headers from the markdown body (the part
+ * after the closing `---` of the frontmatter block).
+ *
+ * @param {string} sourceText - Full SKILL.md content.
+ * @returns {Array<{heading: string, line: number, contentLength: number}>}
+ *   Each entry has the heading text (without `## `), the 1-based line number
+ *   of the `## …` line, and the number of non-whitespace characters in the
+ *   section body (i.e. between this H2 and the next one or end-of-file).
+ */
+function extractH2Sections(sourceText) {
+  const lines = sourceText.split(/\r?\n/);
+
+  // Find the end of the frontmatter block (second `---`).
+  let bodyStart = 0;
+  let dashCount = 0;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trim() === '---') {
+      dashCount++;
+      if (dashCount === 2) { bodyStart = i + 1; break; }
+    }
+  }
+
+  // Collect H2 positions in body.
+  const h2s = [];
+  for (let i = bodyStart; i < lines.length; i++) {
+    const m = lines[i].match(/^## (.+)$/);
+    if (m) {
+      h2s.push({ heading: m[1].trim(), lineIdx: i });
+    }
+  }
+
+  // For each H2, measure how many non-whitespace characters are in its body.
+  const sections = [];
+  for (let j = 0; j < h2s.length; j++) {
+    const start = h2s[j].lineIdx + 1;
+    const end   = j + 1 < h2s.length ? h2s[j + 1].lineIdx : lines.length;
+    const body  = lines.slice(start, end).join('\n');
+    sections.push({
+      heading:       h2s[j].heading,
+      line:          h2s[j].lineIdx + 1, // 1-based
+      contentLength: body.replace(/\s/g, '').length,
+    });
+  }
+
+  return sections;
+}
+
+/**
+ * Run archetype-aware section validation on one SKILL.md file.
+ *
+ * @param {object} opts
+ * @param {string} opts.filePath   - Path to the file (used in messages).
+ * @param {string} opts.sourceText - Full file content.
+ * @param {object} opts.fm         - Parsed frontmatter object.
+ * @param {number} [opts.emptyThreshold=50] - Minimum non-whitespace characters for
+ *   a section to be considered non-empty.
+ *
+ * @returns {{
+ *   errors: Array<{message: string, line: number, column: number, help: string}>,
+ *   warnings: Array<{message: string, line: number, column: number, help: string}>
+ * }}
+ */
+function checkArchetypeSections(opts) {
+  const {
+    filePath,
+    sourceText,
+    fm,
+    emptyThreshold = 50,
+  } = opts;
+
+  const errors   = [];
+  const warnings = [];
+
+  if (!fm || !fm.type) {
+    // Cannot validate without a type — schema check handles missing type.
+    return { errors, warnings };
+  }
+
+  const archetype = fm.type;
+  const required  = REQUIRED_SECTIONS[archetype];
+
+  if (!required) {
+    // Unknown archetype — schema check handles this.
+    return { errors, warnings };
+  }
+
+  const sections = extractH2Sections(sourceText);
+  const presentHeadings = new Set(sections.map(s => s.heading));
+
+  // Error: missing required sections.
+  for (const req of required) {
+    if (!presentHeadings.has(req)) {
+      // Point at line 1 col 1 (frontmatter type: field would be ideal but
+      // locateYamlKey is in the parent; use line 1 as a safe fallback — the
+      // formatter still shows the file reference clearly).
+      errors.push({
+        message: `missing required section "## ${req}" for archetype "${archetype}"`,
+        line:    1,
+        column:  1,
+        help:    `Add a "## ${req}" section. Required sections for ${archetype}: ${required.map(r => `"## ${r}"`).join(', ')}. See docs/skill-metadata-protocol.md § Archetype Section Map.`,
+      });
+    }
+  }
+
+  // Conditional sections — required when frontmatter predicate holds.
+  for (const { section, predicate, help } of CONDITIONAL_SECTIONS) {
+    if (!predicate(fm)) continue;
+    if (presentHeadings.has(section)) continue;
+    errors.push({
+      message: `missing required section "## ${section}" (conditional: eval_artifacts is "${fm && fm.eval_artifacts}")`,
+      line:    1,
+      column:  1,
+      help,
+    });
+  }
+
+  // Warn: sections present but empty.
+  for (const section of sections) {
+    if (section.contentLength < emptyThreshold) {
+      warnings.push({
+        message: `section "## ${section.heading}" exists but appears empty (${section.contentLength} non-whitespace chars, threshold ${emptyThreshold})`,
+        line:    section.line,
+        column:  1,
+        help:    `Fill in the "## ${section.heading}" section or remove it if it is not needed for this archetype.`,
+      });
+    }
+  }
+
+  return { errors, warnings };
+}
+
+module.exports = { checkArchetypeSections, REQUIRED_SECTIONS };

package/scripts/lint/check-category-enum.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+/**
+ * Category enum check for SKILL.md files (Check 13).
+ *
+ * The Skill Graph policy is that `category` functions as a **browse facet**,
+ * not ontology truth, and must take exactly one of six canonical values.
+ *
+ * Post-Phase-1 (v5 schema bump, skill-graph commit `f489641`, 2026-05-16):
+ * the canonical enum is closed at BOTH the schema level (`schemas/skill.schema.json`
+ * `category.enum`) AND this lint level. This file is now redundant-but-correct:
+ * the schema will reject invalid values first, and this lint provides a
+ * second-layer guarantee with a more descriptive error message and the
+ * authoritative definitions inline.
+ *
+ * Both sources of truth must stay in sync. A future protocol revision that
+ * adds (e.g.) a 7th category must update three places in the same commit:
+ *   1. `schemas/skill.schema.json` `category.enum`
+ *   2. `CATEGORY_ENUM` below
+ *   3. `docs/skill-metadata-protocol.md` § Category
+ *
+ * @module lint/check-category-enum
+ */
+
+'use strict';
+
+/**
+ * Canonical category enum — closed set as of v5 (2026-05-16).
+ *
+ * Mirror of `schemas/skill.schema.json` `category.enum`. Update both in the
+ * same commit when adding/removing values.
+ *
+ * Framed as a BROWSE FACET, not ontology truth. Cross-cutting truth
+ * (a skill that is both engineering and quality, for example) lives in
+ * `relations.related`, not in multiple category memberships.
+ */
+const CATEGORY_ENUM = Object.freeze([
+  'foundations', // Epistemics, grounding, verification, context engineering, reasoning
+  'engineering', // Building software systems
+  'design',      // Visual, interaction, IA, content, motion
+  'quality',     // Cross-cutting non-functional properties (a11y, perf, security, type-safety, testing)
+  'agent',       // Agent-specific concepts (tool design, prompt design, agent state)
+  'product',     // Prioritization, scope, MVP, PRDs, journeys
+]);
+
+/**
+ * Run the category-enum check on one SKILL.md file.
+ *
+ * @param {object} opts
+ * @param {string}  opts.filePath    - Path to the file (used in messages only).
+ * @param {string}  opts.sourceText  - Full file content.
+ * @param {object}  opts.fm          - Parsed frontmatter object.
+ *
+ * @returns {{
+ *   errors:   Array<{message: string, line: number, column: number, help: string}>,
+ *   warnings: Array<{message: string, line: number, column: number, help: string}>
+ * }}
+ */
+function checkCategoryEnum(opts) {
+  const { sourceText, fm } = opts;
+  const errors = [];
+  const warnings = [];
+
+  if (!fm) return { errors, warnings };
+  if (typeof fm.category !== 'string') return { errors, warnings };
+
+  if (!CATEGORY_ENUM.includes(fm.category)) {
+    const lineMatch = sourceText.match(/^category\s*:.*$/m);
+    const lineNumber = lineMatch
+      ? sourceText.substring(0, sourceText.indexOf(lineMatch[0])).split('\n').length
+      : 1;
+
+    errors.push({
+      message: `category "${fm.category}" is not in the canonical enum: ${CATEGORY_ENUM.join(', ')}`,
+      line: lineNumber,
+      column: 1,
+      help: `Pick one of: ${CATEGORY_ENUM.join(', ')}. If the skill is genuinely cross-cutting, primary-category it under its strongest fit and use relations.related for the others. See docs/skill-metadata-protocol.md § Category and docs/plans/skill-taxonomy-v5-and-gap-fill.md.`,
+    });
+  }
+
+  return { errors, warnings };
+}
+
+module.exports = { checkCategoryEnum, CATEGORY_ENUM };

package/scripts/lint/check-routing-eval.js

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+/**
+ * Routing-eval integrity check for SKILL.md files (lint check 12).
+ *
+ * **R3 — routing_eval: present must be executable (ERROR)**
+ *   A skill that declares `routing_eval: present` is claiming its routing
+ *   coverage has been evaluated. The authored fields `examples` and
+ *   `anti_examples` (schema_version 3, v0.5.0) are what the evaluation runs
+ *   against. This check enforces two things:
+ *
+ *     1. If `routing_eval: present`, the skill MUST declare both `examples`
+ *        and `anti_examples` (non-empty). No input — no evaluation possible.
+ *
+ *     2. If `routing_eval: present`, running the harness
+ *        (`scripts/skill-graph-routing-eval.js`) against this skill MUST
+ *        return verdict=PASS. Every FAIL case surfaces as a lint error with
+ *        the failing prompt.
+ *
+ *   This is the gate that turns `routing_eval` from self-assertion into a
+ *   verifiable claim. Before this check, authors could set `present` without
+ *   any executable evidence; after it, `present` is lint-rejected until the
+ *   harness agrees.
+ *
+ * @module lint/check-routing-eval
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { evaluateSkill } = require('../skill-graph-routing-eval');
+const { packageRoot, workspaceRoot } = require('../lib/roots');
+
+const REPO_ROOT = workspaceRoot();
+const PACKAGE_ROOT = packageRoot();
+const DEFAULT_MANIFEST = path.join(REPO_ROOT, 'skills.manifest.json');
+const SAMPLE_MANIFEST = path.join(REPO_ROOT, 'examples', 'skills.manifest.sample.json');
+const PACKAGE_SAMPLE_MANIFEST = path.join(PACKAGE_ROOT, 'examples', 'skills.manifest.sample.json');
+
+/**
+ * Run routing-eval checks on one SKILL.md file.
+ *
+ * @param {object} opts
+ * @param {string}  opts.filePath    - Path to the file (used in messages only).
+ * @param {string}  opts.sourceText  - Full file content.
+ * @param {object}  opts.fm          - Parsed frontmatter object.
+ * @param {object}  [opts.manifest]  - Optional pre-loaded manifest (performance).
+ *
+ * @returns {{
+ *   errors:   Array<{message: string, line: number, column: number, help: string}>,
+ *   warnings: Array<{message: string, line: number, column: number, help: string}>
+ * }}
+ */
+function checkRoutingEval(opts) {
+  const { sourceText, fm } = opts;
+  const errors = [];
+  if (!fm) return { errors, warnings: [] };
+  if (fm.routing_eval !== 'present') return { errors, warnings: [] };
+
+  const keyLine = locateKey(sourceText, 'routing_eval') || { line: 1, column: 1 };
+
+  // Guard 1: examples + anti_examples must exist.
+  const hasExamples = Array.isArray(fm.examples) && fm.examples.length > 0;
+  const hasAnti = Array.isArray(fm.anti_examples) && fm.anti_examples.length > 0;
+  if (!hasExamples || !hasAnti) {
+    errors.push({
+      message: `routing_eval: present without populated examples + anti_examples — the harness has no prompts to evaluate`,
+      line: keyLine.line,
+      column: keyLine.column,
+      help: 'Either populate examples and anti_examples (see docs/field-reference.md § examples and § anti_examples) or set routing_eval to "absent".',
+    });
+    return { errors, warnings: [] };
+  }
+
+  // Guard 2: harness must pass.
+  const manifest = opts.manifest || loadManifest();
+  if (!manifest) {
+    errors.push({
+      message: `routing_eval: present but no manifest is available for the harness — run generate-manifest.js first`,
+      line: keyLine.line,
+      column: keyLine.column,
+      help: 'Run `node scripts/generate-manifest.js --output skills.manifest.json` to produce the manifest the harness evaluates against.',
+    });
+    return { errors, warnings: [] };
+  }
+
+  const skillEntry = (manifest.skills || []).find(s => s.name === fm.name);
+  if (!skillEntry) {
+    errors.push({
+      message: `routing_eval: present but skill "${fm.name}" is not in the manifest — regenerate the manifest`,
+      line: keyLine.line,
+      column: keyLine.column,
+      help: 'The skill must appear in the manifest so the harness can resolve its activation.examples / anti_examples.',
+    });
+    return { errors, warnings: [] };
+  }
+
+  const todayISO = new Date().toISOString().slice(0, 10);
+  const report = evaluateSkill(manifest, skillEntry, todayISO);
+
+  if (report.verdict === 'FAIL') {
+    for (const c of report.cases) {
+      if (c.verdict !== 'FAIL') continue;
+      errors.push({
+        message: `routing_eval: present but [${c.kind}] "${truncate(c.prompt, 72)}" fails — ${c.reason}`,
+        line: keyLine.line,
+        column: keyLine.column,
+        help: 'Either fix the routing signal (keywords / boundary / anti_example) until the harness passes, or set routing_eval to "absent" until you do. Run `node scripts/skill-graph-routing-eval.js --skill ' + fm.name + '` for full diagnostics.',
+      });
+    }
+  }
+
+  return { errors, warnings: [] };
+}
+
+function loadManifest() {
+  const p = fs.existsSync(DEFAULT_MANIFEST)
+    ? DEFAULT_MANIFEST
+    : (fs.existsSync(SAMPLE_MANIFEST) ? SAMPLE_MANIFEST : PACKAGE_SAMPLE_MANIFEST);
+  if (!fs.existsSync(p)) return null;
+  try { return JSON.parse(fs.readFileSync(p, 'utf8')); }
+  catch { return null; }
+}
+
+function locateKey(sourceText, key) {
+  const lines = sourceText.split('\n');
+  let dashCount = 0;
+  let inside = false;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trim() === '---') {
+      dashCount++;
+      if (dashCount === 1) { inside = true; continue; }
+      if (dashCount === 2) break;
+    }
+    if (!inside) continue;
+    const m = lines[i].match(new RegExp(`^(\\s*)${key}\\s*:`));
+    if (m) return { line: i + 1, column: m[1].length + 1 };
+  }
+  return null;
+}
+
+function truncate(s, n) {
+  return s.length <= n ? s : s.slice(0, n - 1) + '\u2026';
+}
+
+module.exports = { checkRoutingEval };

package/scripts/lint/check-routing-quality.js

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+/**
+ * Routing quality checks for SKILL.md files (A2 narrow).
+ *
+ * Only "defensible" heuristics are implemented here — checks with low false-
+ * positive risk and clear remediation paths. Length-threshold heuristics for
+ * description or coverage are intentionally omitted (high false-positive risk
+ * on legitimately terse skills).
+ *
+ * **Check R1 — empty keywords in operational scope (ERROR)**
+ *   A skill with `scope: codebase` or any `routing_bundles` entry is meant to
+ *   be surfaced by a router. An empty `keywords: []` (or no keywords field)
+ *   means the skill cannot be discovered by keyword-based routers. This is
+ *   almost always an authoring mistake.
+ *
+ *   Note: the task spec text says "operational scope" but after SH-5784 the
+ *   v2 scope value is `codebase`. This check targets `scope: codebase` OR
+ *   skills that have a non-empty `routing_bundles` array, matching the intent
+ *   of the original proposal.
+ *
+ * **Check R2 — description verbatim in Coverage section (WARN)**
+ *   The description field is a routing contract (≤3 sentences) and `## Coverage`
+ *   is a scope map (a bulleted topic list). When the description text appears
+ *   verbatim inside `## Coverage`, the two layers have collapsed into one and
+ *   the Coverage section adds no information for a reader who already read the
+ *   frontmatter. This is always a copy-paste mistake.
+ *
+ * @module lint/check-routing-quality
+ */
+
+'use strict';
+
+/**
+ * Run routing-quality checks on one SKILL.md file.
+ *
+ * @param {object} opts
+ * @param {string}  opts.filePath    - Path to the file (used in messages only).
+ * @param {string}  opts.sourceText  - Full file content.
+ * @param {object}  opts.fm          - Parsed frontmatter object.
+ *
+ * @returns {{
+ *   errors:   Array<{message: string, line: number, column: number, help: string}>,
+ *   warnings: Array<{message: string, line: number, column: number, help: string}>
+ * }}
+ */
+function checkRoutingQuality(opts) {
+  const { filePath, sourceText, fm } = opts;
+
+  const errors   = [];
+  const warnings = [];
+
+  if (!fm) return { errors, warnings };
+
+  // ------------------------------------------------------------------ R1
+  // Error: empty keywords for scope: codebase or routing_bundles-having skills.
+  const isCodebaseScope   = fm.scope === 'codebase';
+  const hasRoutingGroups  = Array.isArray(fm.routing_bundles) && fm.routing_bundles.length > 0;
+  // The custom frontmatter parser represents `keywords: []` as the string "[]"
+  // (inline YAML array syntax). Treat that as empty as well.
+  const keywordsEmpty     = !fm.keywords
+    || fm.keywords === '[]'
+    || (Array.isArray(fm.keywords) && fm.keywords.length === 0);
+
+  if ((isCodebaseScope || hasRoutingGroups) && keywordsEmpty) {
+    // Locate the `keywords` key in the frontmatter if it exists, else point at
+    // the `scope` key.
+    const keyLine = locateKeyInFrontmatter(sourceText, 'keywords')
+      || locateKeyInFrontmatter(sourceText, 'scope')
+      || { line: 1, column: 1 };
+
+    const scopeReason = isCodebaseScope
+      ? 'scope: codebase'
+      : `routing_bundles: [${fm.routing_bundles.join(', ')}]`;
+
+    errors.push({
+      message: `keywords: [] for a skill with ${scopeReason} — router cannot discover this skill`,
+      line:    keyLine.line,
+      column:  keyLine.column,
+      help:    'Add at least one keyword to the keywords list. Skills with scope: codebase or routing_bundles must be discoverable by keyword routers. See docs/field-reference.md § keywords.',
+    });
+  }
+
+  // ------------------------------------------------------------------ R2
+  // Warn: description text appears verbatim inside ## Coverage section.
+  const description = typeof fm.description === 'string' ? fm.description.trim() : '';
+  if (description.length > 20) {
+    const coverageContent = extractSectionContent(sourceText, 'Coverage');
+    if (coverageContent !== null && coverageContent.includes(description)) {
+      const sectionLine = locateH2InBody(sourceText, 'Coverage');
+      warnings.push({
+        message: 'description text appears verbatim in ## Coverage — the two layers have collapsed into one',
+        line:    sectionLine ? sectionLine.line : 1,
+        column:  1,
+        help:    'The description is the routing contract (≤3 sentences). ## Coverage is a bulleted scope map. Rewrite ## Coverage as a topic list, removing the copied description sentence. See docs/skill-metadata-protocol.md § Semantic layer discipline.',
+      });
+    }
+  }
+
+  return { errors, warnings };
+}
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Locate a YAML key inside the frontmatter block.
+ * Returns { line, column } (1-based) or null if not found.
+ *
+ * @param {string} sourceText
+ * @param {string} key
+ * @returns {{ line: number, column: number }|null}
+ */
+function locateKeyInFrontmatter(sourceText, key) {
+  const lines = sourceText.split('\n');
+  // Only search inside the frontmatter block (between the two `---` markers).
+  let inFrontmatter = false;
+  let dashCount = 0;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trim() === '---') {
+      dashCount++;
+      if (dashCount === 1) { inFrontmatter = true; continue; }
+      if (dashCount === 2) break; // end of frontmatter
+    }
+    if (!inFrontmatter) continue;
+    const m = lines[i].match(new RegExp(`^(\\s*)${escapeRegex(key)}\\s*:`));
+    if (m) {
+      return { line: i + 1, column: m[1].length + 1 };
+    }
+  }
+  return null;
+}
+
+/**
+ * Extract the text content of a named H2 section from the markdown body
+ * (after the closing `---`).
+ *
+ * @param {string} sourceText
+ * @param {string} heading - Heading text without `## ` prefix.
+ * @returns {string|null} Section content, or null if section not found.
+ */
+function extractSectionContent(sourceText, heading) {
+  const lines = sourceText.split('\n');
+
+  // Skip past frontmatter.
+  let bodyStart = 0;
+  let dashCount = 0;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trim() === '---') {
+      dashCount++;
+      if (dashCount === 2) { bodyStart = i + 1; break; }
+    }
+  }
+
+  const target = `## ${heading}`;
+  let collecting = false;
+  let content = [];
+
+  for (let i = bodyStart; i < lines.length; i++) {
+    if (lines[i].trimEnd() === target) {
+      collecting = true;
+      continue;
+    }
+    if (collecting) {
+      // Stop at the next H2.
+      if (/^## /.test(lines[i])) break;
+      content.push(lines[i]);
+    }
+  }
+
+  return collecting ? content.join('\n') : null;
+}
+
+/**
+ * Locate an H2 heading in the body (after frontmatter).
+ * Returns { line } (1-based) or null.
+ *
+ * @param {string} sourceText
+ * @param {string} heading
+ * @returns {{ line: number }|null}
+ */
+function locateH2InBody(sourceText, heading) {
+  const lines = sourceText.split('\n');
+  let dashCount = 0;
+  let pastFrontmatter = false;
+  const target = `## ${heading}`;
+  for (let i = 0; i < lines.length; i++) {
+    if (!pastFrontmatter) {
+      if (lines[i].trim() === '---') {
+        dashCount++;
+        if (dashCount === 2) pastFrontmatter = true;
+      }
+      continue;
+    }
+    if (lines[i].trimEnd() === target) {
+      return { line: i + 1 };
+    }
+  }
+  return null;
+}
+
+/**
+ * Escape special regex characters.
+ * @param {string} s
+ * @returns {string}
+ */
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+module.exports = { checkRoutingQuality };