@democratize-quality/qualitylens-core 0.1.0

package/dist/matchers/area.matcher.mjs

@@ -0,0 +1,77 @@
+// src/matchers/area.matcher.ts
+var AreaMatcher = class {
+  constructor(areaConfigs) {
+    this.areaConfigs = areaConfigs;
+  }
+  assign(routes) {
+    const areaMap = /* @__PURE__ */ new Map();
+    const uncategorised = [];
+    for (const area of this.areaConfigs) {
+      areaMap.set(area.name, []);
+    }
+    for (const route of routes) {
+      const areaName = this.findBestArea(route.route.path);
+      if (areaName) {
+        areaMap.get(areaName).push(route);
+      } else {
+        uncategorised.push(route);
+      }
+    }
+    const areas = [];
+    for (const [name, areaRoutes] of areaMap.entries()) {
+      if (areaRoutes.length === 0) continue;
+      areas.push(this.buildAreaCoverage(name, areaRoutes));
+    }
+    return { areas, uncategorised };
+  }
+  /**
+   * AI INSTRUCTIONS:
+   * 1. For each area config, check if route path starts with any of its patterns
+   * 2. Among all matching areas, return the one with the LONGEST matching pattern
+   *    (most specific wins — /checkout/payment should prefer /checkout over /)
+   * 3. Return undefined if no area matches
+   */
+  findBestArea(routePath) {
+    let bestArea;
+    let bestLength = 0;
+    for (const area of this.areaConfigs) {
+      for (const pattern of area.patterns) {
+        if (routePath.startsWith(pattern) && pattern.length > bestLength) {
+          bestArea = area.name;
+          bestLength = pattern.length;
+        }
+      }
+    }
+    return bestArea;
+  }
+  /**
+   * AI INSTRUCTIONS: compute AreaCoverage statistics from a list of RouteCoverage.
+   * - coveredRoutes: routes where status !== 'none'
+   * - automatedCount: routes where status === 'automated' or 'both'
+   * - manualOnlyCount: routes where status === 'manual'
+   * - noCoverageCount: routes where status === 'none'
+   * - coveragePercent: Math.round((coveredRoutes / totalRoutes) * 100)
+   */
+  buildAreaCoverage(name, routes) {
+    const totalRoutes = routes.length;
+    const coveredRoutes = routes.filter((r) => r.status !== "none").length;
+    const automatedCount = routes.filter((r) => r.status === "automated" || r.status === "both").length;
+    const manualOnlyCount = routes.filter((r) => r.status === "manual").length;
+    const noCoverageCount = routes.filter((r) => r.status === "none").length;
+    const coveragePercent = totalRoutes > 0 ? Math.round(coveredRoutes / totalRoutes * 100) : 0;
+    return {
+      name,
+      routes,
+      totalRoutes,
+      coveredRoutes,
+      automatedCount,
+      manualOnlyCount,
+      noCoverageCount,
+      coveragePercent
+    };
+  }
+};
+export {
+  AreaMatcher
+};
+//# sourceMappingURL=area.matcher.mjs.map

package/dist/matchers/area.matcher.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/matchers/area.matcher.ts"],"sourcesContent":["/**\n * src/matchers/area.matcher.ts\n * \n * Groups routes into functional areas based on path prefix patterns.\n * Most-specific pattern wins (longest prefix match).\n * \n * AI INSTRUCTIONS: implement assign() using the skeleton below.\n */\n\nimport { AreaCoverage, RouteCoverage, TestGapConfig } from '../core/types'\n\nexport class AreaMatcher {\n  constructor(private areaConfigs: TestGapConfig['areas']) {}\n\n  assign(routes: RouteCoverage[]): {\n    areas: AreaCoverage[]\n    uncategorised: RouteCoverage[]\n  } {\n    const areaMap = new Map<string, RouteCoverage[]>()\n    const uncategorised: RouteCoverage[] = []\n\n    // Initialise area buckets\n    for (const area of this.areaConfigs) {\n      areaMap.set(area.name, [])\n    }\n\n    // Assign each route to the best-matching area\n    for (const route of routes) {\n      const areaName = this.findBestArea(route.route.path)\n      if (areaName) {\n        areaMap.get(areaName)!.push(route)\n      } else {\n        uncategorised.push(route)\n      }\n    }\n\n    // Build AreaCoverage objects\n    const areas: AreaCoverage[] = []\n    for (const [name, areaRoutes] of areaMap.entries()) {\n      if (areaRoutes.length === 0) continue\n      areas.push(this.buildAreaCoverage(name, areaRoutes))\n    }\n\n    return { areas, uncategorised }\n  }\n\n  /**\n   * AI INSTRUCTIONS:\n   * 1. For each area config, check if route path starts with any of its patterns\n   * 2. Among all matching areas, return the one with the LONGEST matching pattern\n   *    (most specific wins — /checkout/payment should prefer /checkout over /)\n   * 3. Return undefined if no area matches\n   */\n  private findBestArea(routePath: string): string | undefined {\n    // TODO (AI): implement\n    let bestArea: string | undefined\n    let bestLength = 0\n\n    for (const area of this.areaConfigs) {\n      for (const pattern of area.patterns) {\n        if (routePath.startsWith(pattern) && pattern.length > bestLength) {\n          bestArea = area.name\n          bestLength = pattern.length\n        }\n      }\n    }\n\n    return bestArea\n  }\n\n  /**\n   * AI INSTRUCTIONS: compute AreaCoverage statistics from a list of RouteCoverage.\n   * - coveredRoutes: routes where status !== 'none'\n   * - automatedCount: routes where status === 'automated' or 'both'\n   * - manualOnlyCount: routes where status === 'manual'\n   * - noCoverageCount: routes where status === 'none'\n   * - coveragePercent: Math.round((coveredRoutes / totalRoutes) * 100)\n   */\n  private buildAreaCoverage(name: string, routes: RouteCoverage[]): AreaCoverage {\n    // TODO (AI): implement\n    const totalRoutes = routes.length\n    const coveredRoutes = routes.filter(r => r.status !== 'none').length\n    const automatedCount = routes.filter(r => r.status === 'automated' || r.status === 'both').length\n    const manualOnlyCount = routes.filter(r => r.status === 'manual').length\n    const noCoverageCount = routes.filter(r => r.status === 'none').length\n    const coveragePercent = totalRoutes > 0 ? Math.round((coveredRoutes / totalRoutes) * 100) : 0\n\n    return {\n      name,\n      routes,\n      totalRoutes,\n      coveredRoutes,\n      automatedCount,\n      manualOnlyCount,\n      noCoverageCount,\n      coveragePercent,\n    }\n  }\n}\n"],"mappings":";AAWO,IAAM,cAAN,MAAkB;AAAA,EACvB,YAAoB,aAAqC;AAArC;AAAA,EAAsC;AAAA,EAE1D,OAAO,QAGL;AACA,UAAM,UAAU,oBAAI,IAA6B;AACjD,UAAM,gBAAiC,CAAC;AAGxC,eAAW,QAAQ,KAAK,aAAa;AACnC,cAAQ,IAAI,KAAK,MAAM,CAAC,CAAC;AAAA,IAC3B;AAGA,eAAW,SAAS,QAAQ;AAC1B,YAAM,WAAW,KAAK,aAAa,MAAM,MAAM,IAAI;AACnD,UAAI,UAAU;AACZ,gBAAQ,IAAI,QAAQ,EAAG,KAAK,KAAK;AAAA,MACnC,OAAO;AACL,sBAAc,KAAK,KAAK;AAAA,MAC1B;AAAA,IACF;AAGA,UAAM,QAAwB,CAAC;AAC/B,eAAW,CAAC,MAAM,UAAU,KAAK,QAAQ,QAAQ,GAAG;AAClD,UAAI,WAAW,WAAW,EAAG;AAC7B,YAAM,KAAK,KAAK,kBAAkB,MAAM,UAAU,CAAC;AAAA,IACrD;AAEA,WAAO,EAAE,OAAO,cAAc;AAAA,EAChC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASQ,aAAa,WAAuC;AAE1D,QAAI;AACJ,QAAI,aAAa;AAEjB,eAAW,QAAQ,KAAK,aAAa;AACnC,iBAAW,WAAW,KAAK,UAAU;AACnC,YAAI,UAAU,WAAW,OAAO,KAAK,QAAQ,SAAS,YAAY;AAChE,qBAAW,KAAK;AAChB,uBAAa,QAAQ;AAAA,QACvB;AAAA,MACF;AAAA,IACF;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUQ,kBAAkB,MAAc,QAAuC;AAE7E,UAAM,cAAc,OAAO;AAC3B,UAAM,gBAAgB,OAAO,OAAO,OAAK,EAAE,WAAW,MAAM,EAAE;AAC9D,UAAM,iBAAiB,OAAO,OAAO,OAAK,EAAE,WAAW,eAAe,EAAE,WAAW,MAAM,EAAE;AAC3F,UAAM,kBAAkB,OAAO,OAAO,OAAK,EAAE,WAAW,QAAQ,EAAE;AAClE,UAAM,kBAAkB,OAAO,OAAO,OAAK,EAAE,WAAW,MAAM,EAAE;AAChE,UAAM,kBAAkB,cAAc,IAAI,KAAK,MAAO,gBAAgB,cAAe,GAAG,IAAI;AAE5F,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/dist/matchers/fuzzy.matcher.d.mts

@@ -0,0 +1,83 @@
+import { AppRoute, TestEntry } from '../core/types.mjs';
+
+/**
+ * src/matchers/fuzzy.matcher.ts
+ *
+ * Core matching logic: maps test descriptions to app routes.
+ *
+ * Strategy (applied in order, stops at first match):
+ *   1. METHOD GATE  — if both route and title carry HTTP method info, they must agree
+ *   2. EXACT        — title contains the exact route path with a path-boundary check
+ *   3. SLUG         — path segments appear in title; param segments require evidence
+ *   4. KEYWORD      — camelCase/hyphen words from segments appear in title
+ *
+ * Non-param and param routes are treated differently in SLUG and KEYWORD:
+ *   - Non-param route (/api/products): require 2+ segment hits AND title must not
+ *     explicitly extend the path as a sub-resource (/api/products/ or /api/products/:)
+ *   - Param route (/api/products/:id): require ALL non-param segments to match AND
+ *     evidence that the title accesses the parameterised segment specifically
+ *
+ * This prevents:
+ *   - Cross-service pollution: cart tests matching product routes
+ *   - Parent/child bleed: /api/products matching tests about /api/products/:id
+ *   - Short-param false positives: 'id' appearing as substring of 'userId', 'discount' etc.
+ */
+
+declare class FuzzyMatcher {
+    /**
+     * Returns a Map keyed by "METHOD path" (or just "path" for method-free routes)
+     * so GET /api/products and POST /api/products get independent entries.
+     */
+    match(routes: AppRoute[], tests: TestEntry[]): Map<string, TestEntry[]>;
+    private testMatchesRoute;
+    /**
+     * Extracts an HTTP method from a test title if present as a standalone word.
+     * Returns null when no verb is found so the caller knows to skip the method gate.
+     */
+    private extractMethodFromTitle;
+    /**
+     * EXACT: title contains the route path with a path-boundary check.
+     * Prevents /api/products from matching a title about /api/products/:id.
+     */
+    private exactMatch;
+    /**
+     * SLUG: meaningful path segments must appear in the title.
+     *
+     * Non-param routes (/api/products):
+     *   - 2+ segments must appear in the title
+     *   - Title must NOT explicitly extend this path as a sub-resource
+     *     (guards against /api/products matching a title about /api/products/:id)
+     *
+     * Param routes (/api/products/:id, /orders/:orderId/items):
+     *   - ALL non-param segments must appear in the title
+     *   - AND the title must contain evidence of the parameterised access
+     */
+    private slugMatch;
+    /**
+     * KEYWORD: segments are split into words (camelCase + hyphens) and matched
+     * against the title.
+     *
+     * Same non-param / param split logic as slugMatch:
+     *   - Non-param routes: 2+ word matches, plus sub-path guard
+     *   - Param routes: ALL non-param words must match, plus param evidence
+     */
+    private keywordMatch;
+    /**
+     * Returns true if the test title explicitly extends the given non-param route
+     * as a sub-resource — e.g. "/api/products/" or "/api/products/:" in the title.
+     * Used to prevent non-param routes from matching tests about their child routes.
+     */
+    private titleExtendsPath;
+    /**
+     * Returns true when the title provides evidence of parameterised access:
+     *   - The literal param placeholder (':id', ':userId') appears in the title
+     *   - A concrete numeric ID appears (e.g. /products/42)
+     *   - A UUID-like value appears
+     *   - The param name itself appears — only if >= 3 chars to avoid 'id' matching
+     *     as a substring of 'userId', 'discount', 'modified', etc.
+     */
+    private hasParamEvidence;
+    private splitCamelCase;
+}
+
+export { FuzzyMatcher };

package/dist/matchers/fuzzy.matcher.d.ts

@@ -0,0 +1,83 @@
+import { AppRoute, TestEntry } from '../core/types.js';
+
+/**
+ * src/matchers/fuzzy.matcher.ts
+ *
+ * Core matching logic: maps test descriptions to app routes.
+ *
+ * Strategy (applied in order, stops at first match):
+ *   1. METHOD GATE  — if both route and title carry HTTP method info, they must agree
+ *   2. EXACT        — title contains the exact route path with a path-boundary check
+ *   3. SLUG         — path segments appear in title; param segments require evidence
+ *   4. KEYWORD      — camelCase/hyphen words from segments appear in title
+ *
+ * Non-param and param routes are treated differently in SLUG and KEYWORD:
+ *   - Non-param route (/api/products): require 2+ segment hits AND title must not
+ *     explicitly extend the path as a sub-resource (/api/products/ or /api/products/:)
+ *   - Param route (/api/products/:id): require ALL non-param segments to match AND
+ *     evidence that the title accesses the parameterised segment specifically
+ *
+ * This prevents:
+ *   - Cross-service pollution: cart tests matching product routes
+ *   - Parent/child bleed: /api/products matching tests about /api/products/:id
+ *   - Short-param false positives: 'id' appearing as substring of 'userId', 'discount' etc.
+ */
+
+declare class FuzzyMatcher {
+    /**
+     * Returns a Map keyed by "METHOD path" (or just "path" for method-free routes)
+     * so GET /api/products and POST /api/products get independent entries.
+     */
+    match(routes: AppRoute[], tests: TestEntry[]): Map<string, TestEntry[]>;
+    private testMatchesRoute;
+    /**
+     * Extracts an HTTP method from a test title if present as a standalone word.
+     * Returns null when no verb is found so the caller knows to skip the method gate.
+     */
+    private extractMethodFromTitle;
+    /**
+     * EXACT: title contains the route path with a path-boundary check.
+     * Prevents /api/products from matching a title about /api/products/:id.
+     */
+    private exactMatch;
+    /**
+     * SLUG: meaningful path segments must appear in the title.
+     *
+     * Non-param routes (/api/products):
+     *   - 2+ segments must appear in the title
+     *   - Title must NOT explicitly extend this path as a sub-resource
+     *     (guards against /api/products matching a title about /api/products/:id)
+     *
+     * Param routes (/api/products/:id, /orders/:orderId/items):
+     *   - ALL non-param segments must appear in the title
+     *   - AND the title must contain evidence of the parameterised access
+     */
+    private slugMatch;
+    /**
+     * KEYWORD: segments are split into words (camelCase + hyphens) and matched
+     * against the title.
+     *
+     * Same non-param / param split logic as slugMatch:
+     *   - Non-param routes: 2+ word matches, plus sub-path guard
+     *   - Param routes: ALL non-param words must match, plus param evidence
+     */
+    private keywordMatch;
+    /**
+     * Returns true if the test title explicitly extends the given non-param route
+     * as a sub-resource — e.g. "/api/products/" or "/api/products/:" in the title.
+     * Used to prevent non-param routes from matching tests about their child routes.
+     */
+    private titleExtendsPath;
+    /**
+     * Returns true when the title provides evidence of parameterised access:
+     *   - The literal param placeholder (':id', ':userId') appears in the title
+     *   - A concrete numeric ID appears (e.g. /products/42)
+     *   - A UUID-like value appears
+     *   - The param name itself appears — only if >= 3 chars to avoid 'id' matching
+     *     as a substring of 'userId', 'discount', 'modified', etc.
+     */
+    private hasParamEvidence;
+    private splitCamelCase;
+}
+
+export { FuzzyMatcher };

package/dist/matchers/fuzzy.matcher.js

@@ -0,0 +1,161 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/matchers/fuzzy.matcher.ts
+var fuzzy_matcher_exports = {};
+__export(fuzzy_matcher_exports, {
+  FuzzyMatcher: () => FuzzyMatcher
+});
+module.exports = __toCommonJS(fuzzy_matcher_exports);
+var HTTP_METHODS = ["DELETE", "OPTIONS", "PATCH", "POST", "HEAD", "GET", "PUT"];
+var FuzzyMatcher = class {
+  /**
+   * Returns a Map keyed by "METHOD path" (or just "path" for method-free routes)
+   * so GET /api/products and POST /api/products get independent entries.
+   */
+  match(routes, tests) {
+    const result = /* @__PURE__ */ new Map();
+    for (const route of routes) {
+      const matched = tests.filter(
+        (test) => this.testMatchesRoute(test.title, route.path, route.method)
+      );
+      if (matched.length > 0) {
+        const key = route.method ? `${route.method} ${route.path}` : route.path;
+        result.set(key, matched);
+      }
+    }
+    return result;
+  }
+  testMatchesRoute(title, routePath, routeMethod) {
+    const t = title.toLowerCase();
+    if (routeMethod) {
+      const titleMethod = this.extractMethodFromTitle(title);
+      if (titleMethod && titleMethod !== routeMethod.toUpperCase()) {
+        return false;
+      }
+    }
+    return this.exactMatch(t, routePath) || this.slugMatch(t, routePath) || this.keywordMatch(t, routePath);
+  }
+  /**
+   * Extracts an HTTP method from a test title if present as a standalone word.
+   * Returns null when no verb is found so the caller knows to skip the method gate.
+   */
+  extractMethodFromTitle(title) {
+    const upper = title.toUpperCase();
+    for (const method of HTTP_METHODS) {
+      if (new RegExp(`\\b${method}\\b`).test(upper)) return method;
+    }
+    return null;
+  }
+  /**
+   * EXACT: title contains the route path with a path-boundary check.
+   * Prevents /api/products from matching a title about /api/products/:id.
+   */
+  exactMatch(title, routePath) {
+    const route = routePath.toLowerCase();
+    const idx = title.indexOf(route);
+    if (idx === -1) return false;
+    const charAfter = title[idx + route.length];
+    return charAfter === void 0 || /[\s?#\n]/.test(charAfter);
+  }
+  /**
+   * SLUG: meaningful path segments must appear in the title.
+   *
+   * Non-param routes (/api/products):
+   *   - 2+ segments must appear in the title
+   *   - Title must NOT explicitly extend this path as a sub-resource
+   *     (guards against /api/products matching a title about /api/products/:id)
+   *
+   * Param routes (/api/products/:id, /orders/:orderId/items):
+   *   - ALL non-param segments must appear in the title
+   *   - AND the title must contain evidence of the parameterised access
+   */
+  slugMatch(title, routePath) {
+    const route = routePath.toLowerCase();
+    const allSegments = route.split("/").filter((s) => s.length > 0);
+    const nonParamSegs = allSegments.filter((s) => !s.startsWith(":"));
+    const paramSegs = allSegments.filter((s) => s.startsWith(":"));
+    if (allSegments.length === 0) return false;
+    const nonParamHits = nonParamSegs.filter((seg) => title.includes(seg)).length;
+    if (paramSegs.length === 0) {
+      const threshold = nonParamSegs.length === 1 ? 1 : 2;
+      if (nonParamHits < threshold) return false;
+      return !this.titleExtendsPath(title, nonParamSegs);
+    }
+    if (nonParamHits < nonParamSegs.length) return false;
+    return this.hasParamEvidence(title, paramSegs);
+  }
+  /**
+   * KEYWORD: segments are split into words (camelCase + hyphens) and matched
+   * against the title.
+   *
+   * Same non-param / param split logic as slugMatch:
+   *   - Non-param routes: 2+ word matches, plus sub-path guard
+   *   - Param routes: ALL non-param words must match, plus param evidence
+   */
+  keywordMatch(title, routePath) {
+    const route = routePath.toLowerCase();
+    const allSegments = route.split("/").filter((s) => s.length > 0);
+    const nonParamSegs = allSegments.filter((s) => !s.startsWith(":"));
+    const paramSegs = allSegments.filter((s) => s.startsWith(":"));
+    const nonParamWords = nonParamSegs.flatMap((seg) => seg.split("-")).flatMap((seg) => this.splitCamelCase(seg)).map((w) => w.toLowerCase()).filter((w) => w.length >= 3);
+    if (nonParamWords.length === 0 && paramSegs.length === 0) return false;
+    const nonParamMatchCount = nonParamWords.filter((w) => title.includes(w)).length;
+    if (paramSegs.length === 0) {
+      if (nonParamMatchCount < Math.min(2, nonParamWords.length)) return false;
+      return !this.titleExtendsPath(title, nonParamSegs);
+    }
+    if (nonParamMatchCount < nonParamWords.length) return false;
+    return this.hasParamEvidence(title, paramSegs);
+  }
+  /**
+   * Returns true if the test title explicitly extends the given non-param route
+   * as a sub-resource — e.g. "/api/products/" or "/api/products/:" in the title.
+   * Used to prevent non-param routes from matching tests about their child routes.
+   */
+  titleExtendsPath(title, nonParamSegs) {
+    const reconstructed = "/" + nonParamSegs.join("/");
+    return title.includes(reconstructed + "/") || title.includes(reconstructed + ":");
+  }
+  /**
+   * Returns true when the title provides evidence of parameterised access:
+   *   - The literal param placeholder (':id', ':userId') appears in the title
+   *   - A concrete numeric ID appears (e.g. /products/42)
+   *   - A UUID-like value appears
+   *   - The param name itself appears — only if >= 3 chars to avoid 'id' matching
+   *     as a substring of 'userId', 'discount', 'modified', etc.
+   */
+  hasParamEvidence(title, paramSegs) {
+    return paramSegs.some((param) => {
+      const paramName = param.slice(1).toLowerCase();
+      return title.includes(":" + paramName) || // literal ':id' in title
+      /\b\d+\b/.test(title) || // concrete numeric ID
+      /\b[0-9a-f-]{8,}\b/.test(title) || // UUID-like value
+      paramName.length >= 3 && title.includes(paramName);
+    });
+  }
+  splitCamelCase(str) {
+    return str.replace(/([A-Z])/g, " $1").trim().split(" ").filter(Boolean);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FuzzyMatcher
+});
+//# sourceMappingURL=fuzzy.matcher.js.map

package/dist/matchers/fuzzy.matcher.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/matchers/fuzzy.matcher.ts"],"sourcesContent":["/**\n * src/matchers/fuzzy.matcher.ts\n *\n * Core matching logic: maps test descriptions to app routes.\n *\n * Strategy (applied in order, stops at first match):\n *   1. METHOD GATE  — if both route and title carry HTTP method info, they must agree\n *   2. EXACT        — title contains the exact route path with a path-boundary check\n *   3. SLUG         — path segments appear in title; param segments require evidence\n *   4. KEYWORD      — camelCase/hyphen words from segments appear in title\n *\n * Non-param and param routes are treated differently in SLUG and KEYWORD:\n *   - Non-param route (/api/products): require 2+ segment hits AND title must not\n *     explicitly extend the path as a sub-resource (/api/products/ or /api/products/:)\n *   - Param route (/api/products/:id): require ALL non-param segments to match AND\n *     evidence that the title accesses the parameterised segment specifically\n *\n * This prevents:\n *   - Cross-service pollution: cart tests matching product routes\n *   - Parent/child bleed: /api/products matching tests about /api/products/:id\n *   - Short-param false positives: 'id' appearing as substring of 'userId', 'discount' etc.\n */\n\nimport { AppRoute, TestEntry } from '../core/types'\n\nconst HTTP_METHODS = ['DELETE', 'OPTIONS', 'PATCH', 'POST', 'HEAD', 'GET', 'PUT']\n\nexport class FuzzyMatcher {\n  /**\n   * Returns a Map keyed by \"METHOD path\" (or just \"path\" for method-free routes)\n   * so GET /api/products and POST /api/products get independent entries.\n   */\n  match(routes: AppRoute[], tests: TestEntry[]): Map<string, TestEntry[]> {\n    const result = new Map<string, TestEntry[]>()\n\n    for (const route of routes) {\n      const matched = tests.filter(test =>\n        this.testMatchesRoute(test.title, route.path, route.method)\n      )\n      if (matched.length > 0) {\n        const key = route.method ? `${route.method} ${route.path}` : route.path\n        result.set(key, matched)\n      }\n    }\n\n    return result\n  }\n\n  private testMatchesRoute(title: string, routePath: string, routeMethod?: string): boolean {\n    const t = title.toLowerCase()\n\n    // ── Method gate ────────────────────────────────────────────────────────────\n    // Only fires when BOTH the route has a method AND the title contains an HTTP\n    // verb. Tests without a verb (e.g. \"should return product list\") skip the gate\n    // and proceed to fuzzy matching unchanged — backwards compatible.\n    if (routeMethod) {\n      const titleMethod = this.extractMethodFromTitle(title)\n      if (titleMethod && titleMethod !== routeMethod.toUpperCase()) {\n        return false\n      }\n    }\n\n    return (\n      this.exactMatch(t, routePath) ||\n      this.slugMatch(t, routePath) ||\n      this.keywordMatch(t, routePath)\n    )\n  }\n\n  /**\n   * Extracts an HTTP method from a test title if present as a standalone word.\n   * Returns null when no verb is found so the caller knows to skip the method gate.\n   */\n  private extractMethodFromTitle(title: string): string | null {\n    const upper = title.toUpperCase()\n    for (const method of HTTP_METHODS) {\n      if (new RegExp(`\\\\b${method}\\\\b`).test(upper)) return method\n    }\n    return null\n  }\n\n  /**\n   * EXACT: title contains the route path with a path-boundary check.\n   * Prevents /api/products from matching a title about /api/products/:id.\n   */\n  private exactMatch(title: string, routePath: string): boolean {\n    const route = routePath.toLowerCase()\n    const idx = title.indexOf(route)\n    if (idx === -1) return false\n    const charAfter = title[idx + route.length]\n    // Reject if the matched path continues as a deeper segment\n    return charAfter === undefined || /[\\s?#\\n]/.test(charAfter)\n  }\n\n  /**\n   * SLUG: meaningful path segments must appear in the title.\n   *\n   * Non-param routes (/api/products):\n   *   - 2+ segments must appear in the title\n   *   - Title must NOT explicitly extend this path as a sub-resource\n   *     (guards against /api/products matching a title about /api/products/:id)\n   *\n   * Param routes (/api/products/:id, /orders/:orderId/items):\n   *   - ALL non-param segments must appear in the title\n   *   - AND the title must contain evidence of the parameterised access\n   */\n  private slugMatch(title: string, routePath: string): boolean {\n    const route = routePath.toLowerCase()\n    const allSegments = route.split('/').filter(s => s.length > 0)\n    const nonParamSegs = allSegments.filter(s => !s.startsWith(':'))\n    const paramSegs    = allSegments.filter(s => s.startsWith(':'))\n\n    if (allSegments.length === 0) return false\n\n    const nonParamHits = nonParamSegs.filter(seg => title.includes(seg)).length\n\n    if (paramSegs.length === 0) {\n      // Non-param route\n      const threshold = nonParamSegs.length === 1 ? 1 : 2\n      if (nonParamHits < threshold) return false\n      return !this.titleExtendsPath(title, nonParamSegs)\n    }\n\n    // Param route: all non-param segments must match, then check param evidence\n    if (nonParamHits < nonParamSegs.length) return false\n    return this.hasParamEvidence(title, paramSegs)\n  }\n\n  /**\n   * KEYWORD: segments are split into words (camelCase + hyphens) and matched\n   * against the title.\n   *\n   * Same non-param / param split logic as slugMatch:\n   *   - Non-param routes: 2+ word matches, plus sub-path guard\n   *   - Param routes: ALL non-param words must match, plus param evidence\n   */\n  private keywordMatch(title: string, routePath: string): boolean {\n    const route = routePath.toLowerCase()\n    const allSegments = route.split('/').filter(s => s.length > 0)\n    const nonParamSegs = allSegments.filter(s => !s.startsWith(':'))\n    const paramSegs    = allSegments.filter(s => s.startsWith(':'))\n\n    const nonParamWords = nonParamSegs\n      .flatMap(seg => seg.split('-'))\n      .flatMap(seg => this.splitCamelCase(seg))\n      .map(w => w.toLowerCase())\n      .filter(w => w.length >= 3)\n\n    if (nonParamWords.length === 0 && paramSegs.length === 0) return false\n\n    const nonParamMatchCount = nonParamWords.filter(w => title.includes(w)).length\n\n    if (paramSegs.length === 0) {\n      // Non-param route\n      if (nonParamMatchCount < Math.min(2, nonParamWords.length)) return false\n      return !this.titleExtendsPath(title, nonParamSegs)\n    }\n\n    // Param route: ALL non-param words must match first — this is the key guard\n    // against cross-service false positives (cart tests have 'api' but not 'products')\n    if (nonParamMatchCount < nonParamWords.length) return false\n    return this.hasParamEvidence(title, paramSegs)\n  }\n\n  /**\n   * Returns true if the test title explicitly extends the given non-param route\n   * as a sub-resource — e.g. \"/api/products/\" or \"/api/products/:\" in the title.\n   * Used to prevent non-param routes from matching tests about their child routes.\n   */\n  private titleExtendsPath(title: string, nonParamSegs: string[]): boolean {\n    const reconstructed = '/' + nonParamSegs.join('/')\n    return title.includes(reconstructed + '/') || title.includes(reconstructed + ':')\n  }\n\n  /**\n   * Returns true when the title provides evidence of parameterised access:\n   *   - The literal param placeholder (':id', ':userId') appears in the title\n   *   - A concrete numeric ID appears (e.g. /products/42)\n   *   - A UUID-like value appears\n   *   - The param name itself appears — only if >= 3 chars to avoid 'id' matching\n   *     as a substring of 'userId', 'discount', 'modified', etc.\n   */\n  private hasParamEvidence(title: string, paramSegs: string[]): boolean {\n    return paramSegs.some(param => {\n      const paramName = param.slice(1).toLowerCase()  // ':userId' → 'userid'\n      return (\n        title.includes(':' + paramName) ||             // literal ':id' in title\n        /\\b\\d+\\b/.test(title) ||                       // concrete numeric ID\n        /\\b[0-9a-f-]{8,}\\b/.test(title) ||            // UUID-like value\n        (paramName.length >= 3 && title.includes(paramName))  // name only if long enough\n      )\n    })\n  }\n\n  private splitCamelCase(str: string): string[] {\n    return str.replace(/([A-Z])/g, ' $1').trim().split(' ').filter(Boolean)\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/matchers/fuzzy.matcher.mjs

@@ -0,0 +1,136 @@
+// src/matchers/fuzzy.matcher.ts
+var HTTP_METHODS = ["DELETE", "OPTIONS", "PATCH", "POST", "HEAD", "GET", "PUT"];
+var FuzzyMatcher = class {
+  /**
+   * Returns a Map keyed by "METHOD path" (or just "path" for method-free routes)
+   * so GET /api/products and POST /api/products get independent entries.
+   */
+  match(routes, tests) {
+    const result = /* @__PURE__ */ new Map();
+    for (const route of routes) {
+      const matched = tests.filter(
+        (test) => this.testMatchesRoute(test.title, route.path, route.method)
+      );
+      if (matched.length > 0) {
+        const key = route.method ? `${route.method} ${route.path}` : route.path;
+        result.set(key, matched);
+      }
+    }
+    return result;
+  }
+  testMatchesRoute(title, routePath, routeMethod) {
+    const t = title.toLowerCase();
+    if (routeMethod) {
+      const titleMethod = this.extractMethodFromTitle(title);
+      if (titleMethod && titleMethod !== routeMethod.toUpperCase()) {
+        return false;
+      }
+    }
+    return this.exactMatch(t, routePath) || this.slugMatch(t, routePath) || this.keywordMatch(t, routePath);
+  }
+  /**
+   * Extracts an HTTP method from a test title if present as a standalone word.
+   * Returns null when no verb is found so the caller knows to skip the method gate.
+   */
+  extractMethodFromTitle(title) {
+    const upper = title.toUpperCase();
+    for (const method of HTTP_METHODS) {
+      if (new RegExp(`\\b${method}\\b`).test(upper)) return method;
+    }
+    return null;
+  }
+  /**
+   * EXACT: title contains the route path with a path-boundary check.
+   * Prevents /api/products from matching a title about /api/products/:id.
+   */
+  exactMatch(title, routePath) {
+    const route = routePath.toLowerCase();
+    const idx = title.indexOf(route);
+    if (idx === -1) return false;
+    const charAfter = title[idx + route.length];
+    return charAfter === void 0 || /[\s?#\n]/.test(charAfter);
+  }
+  /**
+   * SLUG: meaningful path segments must appear in the title.
+   *
+   * Non-param routes (/api/products):
+   *   - 2+ segments must appear in the title
+   *   - Title must NOT explicitly extend this path as a sub-resource
+   *     (guards against /api/products matching a title about /api/products/:id)
+   *
+   * Param routes (/api/products/:id, /orders/:orderId/items):
+   *   - ALL non-param segments must appear in the title
+   *   - AND the title must contain evidence of the parameterised access
+   */
+  slugMatch(title, routePath) {
+    const route = routePath.toLowerCase();
+    const allSegments = route.split("/").filter((s) => s.length > 0);
+    const nonParamSegs = allSegments.filter((s) => !s.startsWith(":"));
+    const paramSegs = allSegments.filter((s) => s.startsWith(":"));
+    if (allSegments.length === 0) return false;
+    const nonParamHits = nonParamSegs.filter((seg) => title.includes(seg)).length;
+    if (paramSegs.length === 0) {
+      const threshold = nonParamSegs.length === 1 ? 1 : 2;
+      if (nonParamHits < threshold) return false;
+      return !this.titleExtendsPath(title, nonParamSegs);
+    }
+    if (nonParamHits < nonParamSegs.length) return false;
+    return this.hasParamEvidence(title, paramSegs);
+  }
+  /**
+   * KEYWORD: segments are split into words (camelCase + hyphens) and matched
+   * against the title.
+   *
+   * Same non-param / param split logic as slugMatch:
+   *   - Non-param routes: 2+ word matches, plus sub-path guard
+   *   - Param routes: ALL non-param words must match, plus param evidence
+   */
+  keywordMatch(title, routePath) {
+    const route = routePath.toLowerCase();
+    const allSegments = route.split("/").filter((s) => s.length > 0);
+    const nonParamSegs = allSegments.filter((s) => !s.startsWith(":"));
+    const paramSegs = allSegments.filter((s) => s.startsWith(":"));
+    const nonParamWords = nonParamSegs.flatMap((seg) => seg.split("-")).flatMap((seg) => this.splitCamelCase(seg)).map((w) => w.toLowerCase()).filter((w) => w.length >= 3);
+    if (nonParamWords.length === 0 && paramSegs.length === 0) return false;
+    const nonParamMatchCount = nonParamWords.filter((w) => title.includes(w)).length;
+    if (paramSegs.length === 0) {
+      if (nonParamMatchCount < Math.min(2, nonParamWords.length)) return false;
+      return !this.titleExtendsPath(title, nonParamSegs);
+    }
+    if (nonParamMatchCount < nonParamWords.length) return false;
+    return this.hasParamEvidence(title, paramSegs);
+  }
+  /**
+   * Returns true if the test title explicitly extends the given non-param route
+   * as a sub-resource — e.g. "/api/products/" or "/api/products/:" in the title.
+   * Used to prevent non-param routes from matching tests about their child routes.
+   */
+  titleExtendsPath(title, nonParamSegs) {
+    const reconstructed = "/" + nonParamSegs.join("/");
+    return title.includes(reconstructed + "/") || title.includes(reconstructed + ":");
+  }
+  /**
+   * Returns true when the title provides evidence of parameterised access:
+   *   - The literal param placeholder (':id', ':userId') appears in the title
+   *   - A concrete numeric ID appears (e.g. /products/42)
+   *   - A UUID-like value appears
+   *   - The param name itself appears — only if >= 3 chars to avoid 'id' matching
+   *     as a substring of 'userId', 'discount', 'modified', etc.
+   */
+  hasParamEvidence(title, paramSegs) {
+    return paramSegs.some((param) => {
+      const paramName = param.slice(1).toLowerCase();
+      return title.includes(":" + paramName) || // literal ':id' in title
+      /\b\d+\b/.test(title) || // concrete numeric ID
+      /\b[0-9a-f-]{8,}\b/.test(title) || // UUID-like value
+      paramName.length >= 3 && title.includes(paramName);
+    });
+  }
+  splitCamelCase(str) {
+    return str.replace(/([A-Z])/g, " $1").trim().split(" ").filter(Boolean);
+  }
+};
+export {
+  FuzzyMatcher
+};
+//# sourceMappingURL=fuzzy.matcher.mjs.map

package/dist/matchers/fuzzy.matcher.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/matchers/fuzzy.matcher.ts"],"sourcesContent":["/**\n * src/matchers/fuzzy.matcher.ts\n *\n * Core matching logic: maps test descriptions to app routes.\n *\n * Strategy (applied in order, stops at first match):\n *   1. METHOD GATE  — if both route and title carry HTTP method info, they must agree\n *   2. EXACT        — title contains the exact route path with a path-boundary check\n *   3. SLUG         — path segments appear in title; param segments require evidence\n *   4. KEYWORD      — camelCase/hyphen words from segments appear in title\n *\n * Non-param and param routes are treated differently in SLUG and KEYWORD:\n *   - Non-param route (/api/products): require 2+ segment hits AND title must not\n *     explicitly extend the path as a sub-resource (/api/products/ or /api/products/:)\n *   - Param route (/api/products/:id): require ALL non-param segments to match AND\n *     evidence that the title accesses the parameterised segment specifically\n *\n * This prevents:\n *   - Cross-service pollution: cart tests matching product routes\n *   - Parent/child bleed: /api/products matching tests about /api/products/:id\n *   - Short-param false positives: 'id' appearing as substring of 'userId', 'discount' etc.\n */\n\nimport { AppRoute, TestEntry } from '../core/types'\n\nconst HTTP_METHODS = ['DELETE', 'OPTIONS', 'PATCH', 'POST', 'HEAD', 'GET', 'PUT']\n\nexport class FuzzyMatcher {\n  /**\n   * Returns a Map keyed by \"METHOD path\" (or just \"path\" for method-free routes)\n   * so GET /api/products and POST /api/products get independent entries.\n   */\n  match(routes: AppRoute[], tests: TestEntry[]): Map<string, TestEntry[]> {\n    const result = new Map<string, TestEntry[]>()\n\n    for (const route of routes) {\n      const matched = tests.filter(test =>\n        this.testMatchesRoute(test.title, route.path, route.method)\n      )\n      if (matched.length > 0) {\n        const key = route.method ? `${route.method} ${route.path}` : route.path\n        result.set(key, matched)\n      }\n    }\n\n    return result\n  }\n\n  private testMatchesRoute(title: string, routePath: string, routeMethod?: string): boolean {\n    const t = title.toLowerCase()\n\n    // ── Method gate ────────────────────────────────────────────────────────────\n    // Only fires when BOTH the route has a method AND the title contains an HTTP\n    // verb. Tests without a verb (e.g. \"should return product list\") skip the gate\n    // and proceed to fuzzy matching unchanged — backwards compatible.\n    if (routeMethod) {\n      const titleMethod = this.extractMethodFromTitle(title)\n      if (titleMethod && titleMethod !== routeMethod.toUpperCase()) {\n        return false\n      }\n    }\n\n    return (\n      this.exactMatch(t, routePath) ||\n      this.slugMatch(t, routePath) ||\n      this.keywordMatch(t, routePath)\n    )\n  }\n\n  /**\n   * Extracts an HTTP method from a test title if present as a standalone word.\n   * Returns null when no verb is found so the caller knows to skip the method gate.\n   */\n  private extractMethodFromTitle(title: string): string | null {\n    const upper = title.toUpperCase()\n    for (const method of HTTP_METHODS) {\n      if (new RegExp(`\\\\b${method}\\\\b`).test(upper)) return method\n    }\n    return null\n  }\n\n  /**\n   * EXACT: title contains the route path with a path-boundary check.\n   * Prevents /api/products from matching a title about /api/products/:id.\n   */\n  private exactMatch(title: string, routePath: string): boolean {\n    const route = routePath.toLowerCase()\n    const idx = title.indexOf(route)\n    if (idx === -1) return false\n    const charAfter = title[idx + route.length]\n    // Reject if the matched path continues as a deeper segment\n    return charAfter === undefined || /[\\s?#\\n]/.test(charAfter)\n  }\n\n  /**\n   * SLUG: meaningful path segments must appear in the title.\n   *\n   * Non-param routes (/api/products):\n   *   - 2+ segments must appear in the title\n   *   - Title must NOT explicitly extend this path as a sub-resource\n   *     (guards against /api/products matching a title about /api/products/:id)\n   *\n   * Param routes (/api/products/:id, /orders/:orderId/items):\n   *   - ALL non-param segments must appear in the title\n   *   - AND the title must contain evidence of the parameterised access\n   */\n  private slugMatch(title: string, routePath: string): boolean {\n    const route = routePath.toLowerCase()\n    const allSegments = route.split('/').filter(s => s.length > 0)\n    const nonParamSegs = allSegments.filter(s => !s.startsWith(':'))\n    const paramSegs    = allSegments.filter(s => s.startsWith(':'))\n\n    if (allSegments.length === 0) return false\n\n    const nonParamHits = nonParamSegs.filter(seg => title.includes(seg)).length\n\n    if (paramSegs.length === 0) {\n      // Non-param route\n      const threshold = nonParamSegs.length === 1 ? 1 : 2\n      if (nonParamHits < threshold) return false\n      return !this.titleExtendsPath(title, nonParamSegs)\n    }\n\n    // Param route: all non-param segments must match, then check param evidence\n    if (nonParamHits < nonParamSegs.length) return false\n    return this.hasParamEvidence(title, paramSegs)\n  }\n\n  /**\n   * KEYWORD: segments are split into words (camelCase + hyphens) and matched\n   * against the title.\n   *\n   * Same non-param / param split logic as slugMatch:\n   *   - Non-param routes: 2+ word matches, plus sub-path guard\n   *   - Param routes: ALL non-param words must match, plus param evidence\n   */\n  private keywordMatch(title: string, routePath: string): boolean {\n    const route = routePath.toLowerCase()\n    const allSegments = route.split('/').filter(s => s.length > 0)\n    const nonParamSegs = allSegments.filter(s => !s.startsWith(':'))\n    const paramSegs    = allSegments.filter(s => s.startsWith(':'))\n\n    const nonParamWords = nonParamSegs\n      .flatMap(seg => seg.split('-'))\n      .flatMap(seg => this.splitCamelCase(seg))\n      .map(w => w.toLowerCase())\n      .filter(w => w.length >= 3)\n\n    if (nonParamWords.length === 0 && paramSegs.length === 0) return false\n\n    const nonParamMatchCount = nonParamWords.filter(w => title.includes(w)).length\n\n    if (paramSegs.length === 0) {\n      // Non-param route\n      if (nonParamMatchCount < Math.min(2, nonParamWords.length)) return false\n      return !this.titleExtendsPath(title, nonParamSegs)\n    }\n\n    // Param route: ALL non-param words must match first — this is the key guard\n    // against cross-service false positives (cart tests have 'api' but not 'products')\n    if (nonParamMatchCount < nonParamWords.length) return false\n    return this.hasParamEvidence(title, paramSegs)\n  }\n\n  /**\n   * Returns true if the test title explicitly extends the given non-param route\n   * as a sub-resource — e.g. \"/api/products/\" or \"/api/products/:\" in the title.\n   * Used to prevent non-param routes from matching tests about their child routes.\n   */\n  private titleExtendsPath(title: string, nonParamSegs: string[]): boolean {\n    const reconstructed = '/' + nonParamSegs.join('/')\n    return title.includes(reconstructed + '/') || title.includes(reconstructed + ':')\n  }\n\n  /**\n   * Returns true when the title provides evidence of parameterised access:\n   *   - The literal param placeholder (':id', ':userId') appears in the title\n   *   - A concrete numeric ID appears (e.g. /products/42)\n   *   - A UUID-like value appears\n   *   - The param name itself appears — only if >= 3 chars to avoid 'id' matching\n   *     as a substring of 'userId', 'discount', 'modified', etc.\n   */\n  private hasParamEvidence(title: string, paramSegs: string[]): boolean {\n    return paramSegs.some(param => {\n      const paramName = param.slice(1).toLowerCase()  // ':userId' → 'userid'\n      return (\n        title.includes(':' + paramName) ||             // literal ':id' in title\n        /\\b\\d+\\b/.test(title) ||                       // concrete numeric ID\n        /\\b[0-9a-f-]{8,}\\b/.test(title) ||            // UUID-like value\n        (paramName.length >= 3 && title.includes(paramName))  // name only if long enough\n      )\n    })\n  }\n\n  private splitCamelCase(str: string): string[] {\n    return str.replace(/([A-Z])/g, ' $1').trim().split(' ').filter(Boolean)\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/reporters/base.reporter.d.mts

@@ -0,0 +1,19 @@
+import { CoverageReport } from '../core/types.mjs';
+
+/**
+ * src/reporters/base.reporter.ts
+ *
+ * Abstract base class for all reporters.
+ * To add a new output format: extend this class, implement write().
+ */
+
+declare abstract class BaseReporter {
+    abstract readonly name: string;
+    /**
+     * Write the report to the given output path.
+     * For console reporter, outputPath may be ignored.
+     */
+    abstract write(report: CoverageReport, outputPath: string): Promise<void>;
+}
+
+export { BaseReporter };

package/dist/reporters/base.reporter.d.ts

@@ -0,0 +1,19 @@
+import { CoverageReport } from '../core/types.js';
+
+/**
+ * src/reporters/base.reporter.ts
+ *
+ * Abstract base class for all reporters.
+ * To add a new output format: extend this class, implement write().
+ */
+
+declare abstract class BaseReporter {
+    abstract readonly name: string;
+    /**
+     * Write the report to the given output path.
+     * For console reporter, outputPath may be ignored.
+     */
+    abstract write(report: CoverageReport, outputPath: string): Promise<void>;
+}
+
+export { BaseReporter };