@vibecheck-ai/mcp 24.6.8 → 24.6.11

package/dist/chunk-DDTUTWRY.js

@@ -0,0 +1,605 @@
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import { BaseEngine } from './chunk-RR5ETBSV.js';
+
+createRequire(import.meta.url);
+const __filename$1 = fileURLToPath(import.meta.url);
+dirname(__filename$1);
+
+// ../engines/dist/chunk-DTMHBOUB.js
+var FALSY_NUMERIC_NAMES = /\b(count|total|index|idx|amount|balance|quantity|offset|limit|size|length|width|height|age|year|port|code)\b/i;
+function stripLineForLogicScan(line) {
+  let out = "";
+  let i = 0;
+  const n = line.length;
+  while (i < n) {
+    const c = line[i];
+    if (c === "/" && line[i + 1] === "/") {
+      out += " ".repeat(n - i);
+      break;
+    }
+    if (c === "/" && line[i + 1] === "*") {
+      const end = line.indexOf("*/", i + 2);
+      if (end === -1) {
+        out += " ".repeat(n - i);
+        break;
+      }
+      out += " ".repeat(end + 2 - i);
+      i = end + 2;
+      continue;
+    }
+    if (c === "'" || c === '"') {
+      const q = c;
+      let j = i + 1;
+      while (j < n) {
+        if (line[j] === "\\") {
+          j += 2;
+          continue;
+        }
+        if (line[j] === q) {
+          j++;
+          break;
+        }
+        j++;
+      }
+      out += " ".repeat(j - i);
+      i = j;
+      continue;
+    }
+    if (c === "`") {
+      let j = i + 1;
+      while (j < n) {
+        if (line[j] === "\\") {
+          j += 2;
+          continue;
+        }
+        if (line[j] === "$" && line[j + 1] === "{") {
+          let depth = 1;
+          j += 2;
+          while (j < n && depth > 0) {
+            if (line[j] === "{") depth++;
+            else if (line[j] === "}") depth--;
+            j++;
+          }
+          continue;
+        }
+        if (line[j] === "`") {
+          j++;
+          break;
+        }
+        j++;
+      }
+      out += " ".repeat(j - i);
+      i = j;
+      continue;
+    }
+    out += c;
+    i++;
+  }
+  return out;
+}
+function visualIndentLength(line) {
+  let n = 0;
+  for (let i = 0; i < line.length; i++) {
+    const c = line[i];
+    if (c === " ") n++;
+    else if (c === "	") n += 2;
+    else break;
+  }
+  return n;
+}
+function isBareAssignmentAt(s, idx) {
+  if (s[idx] !== "=") return false;
+  const prev = s[idx - 1];
+  const next = s[idx + 1];
+  if (next === "=") return false;
+  if (prev === "=" || prev === "!" || prev === "<" || prev === ">") return false;
+  return true;
+}
+function findAssignmentInConditional(stripped, keyword) {
+  const re = keyword === "if" ? /\bif\s*\(/ : /\bwhile\s*\(/;
+  const m = stripped.match(re);
+  if (!m || m.index === void 0) return null;
+  let i = m.index + m[0].length - 1;
+  if (stripped[i] !== "(") return null;
+  let depth = 0;
+  const start = i;
+  for (; i < stripped.length; i++) {
+    const c = stripped[i];
+    if (c === "(") {
+      depth++;
+      continue;
+    }
+    if (c === ")") {
+      depth--;
+      if (depth === 0) {
+        const inner = stripped.slice(start + 1, i);
+        for (let j = 0; j < inner.length; j++) {
+          if (isBareAssignmentAt(inner, j)) {
+            return m.index + m[0].length + j;
+          }
+        }
+        return null;
+      }
+      continue;
+    }
+  }
+  return null;
+}
+var FALLTHROUGH_COMMENT_RE = /falls?\s*through|fallthrough|intentional\s*fallthrough|fall[\s-]*through/i;
+function segmentHasFallthroughComment(text) {
+  return FALLTHROUGH_COMMENT_RE.test(text);
+}
+function segmentHasExitStatement(strippedSegment) {
+  if (/\b(?:break|continue)\s*;/m.test(strippedSegment)) return true;
+  if (/\breturn\b[^;]*;/m.test(strippedSegment)) return true;
+  if (/\bthrow\b[^;]*;/m.test(strippedSegment)) return true;
+  return false;
+}
+function isTestLikePath(uri) {
+  return /\.(test|spec)\.(ts|tsx|js|jsx)$/i.test(uri) || /(?:^|\/)(?:__tests__|__mocks__|tests?|fixtures?|e2e|spec|cypress|playwright|__snapshots__|stubs?|mocks?)\//i.test(
+    uri
+  );
+}
+function maskEqualityOps(s) {
+  return s.replace(/===/g, "\0A\0").replace(/!==/g, "\0B\0").replace(/=>/g, "\0C\0").replace(/<=/g, "\0D\0").replace(/>=/g, "\0E\0");
+}
+function isLooseNullOrUndefinedCheck(masked, eqIdx) {
+  const rest = masked.slice(eqIdx + 2).trimStart();
+  return /^null\b/.test(rest) || /^undefined\b/.test(rest);
+}
+function findLooseEqualityIssues(masked) {
+  const out = [];
+  for (let i = 0; i < masked.length - 1; i++) {
+    if (masked[i] === "=" && masked[i + 1] === "=") {
+      if (i > 0 && masked[i - 1] === "=") continue;
+      if (i + 2 < masked.length && masked[i + 2] === "=") continue;
+      if (!isLooseNullOrUndefinedCheck(masked, i)) {
+        out.push({ col: i, op: "==" });
+      }
+      i++;
+      continue;
+    }
+    if (masked[i] === "!" && masked[i + 1] === "=") {
+      if (i > 0 && masked[i - 1] === "=") continue;
+      if (i + 2 < masked.length && masked[i + 2] === "=") continue;
+      if (!isLooseNullOrUndefinedCheck(masked, i)) {
+        out.push({ col: i, op: "!=" });
+      }
+      i++;
+    }
+  }
+  return out;
+}
+var DOM_UNGUARDED_RE = /document\.(?:getElementById|querySelector|querySelectorAll)\s*\([^)]+\)\s*(?:\.(?!\?)|\[)/;
+var JSON_PARSE_DOT_RE = /JSON\.parse\s*\([^)]*\)\s*\.\s*(?!catch\b)\w/;
+function lineHasOptionalBeforeJsonDot(line) {
+  return /JSON\.parse\s*\([^)]*\)\s*\?\./.test(line);
+}
+var ARRAY_LENGTH_OOB_RE = /\b([a-zA-Z_$][\w$]*)\[\1\.length\](?!\s*=)/;
+var SUBSTRING_SAME_ARGS_RE = /\bsubstring\s*\(\s*([a-zA-Z_$][\w$]*)\s*,\s*\1\s*\)/;
+var FLOAT_EQ_RE = /\b\d+\.\d+(?!\.\d)\s*(===|!==|==|!=)\s*[\w.$`'"-]+|[\w.$`'"-]+\s*(===|!==|==|!=)\s*\b\d+\.\d+(?!\.\d)\b/;
+function caseLabelLeadingLength(line) {
+  const m = line.match(/^(\s*)(case\b[^:]*:|default\s*:)/);
+  if (!m) return null;
+  return { indent: visualIndentLength(m[1]) };
+}
+var LogicGapEngine = class extends BaseEngine {
+  id = "logic_gap";
+  name = "Logic Gap Engine";
+  version = "1.0.0";
+  supportedExtensions = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx"]);
+  async scan(delta, signal) {
+    const findings = [];
+    const uri = delta.documentUri.replace(/^file:\/\//, "");
+    const source = delta.fullText;
+    const lines = delta.lines ?? source.split("\n");
+    this.checkAbort(signal);
+    if (isTestLikePath(uri)) {
+      return findings;
+    }
+    if (/\/scripts?\//i.test(uri) && /@vibecheck-generated\b/i.test(source.slice(0, 900))) {
+      return findings;
+    }
+    if (!/(?:==|!=|switch\b|case\b|return\b|throw\b|break\b|continue\b|if\s*\(|while\s*\(|indexOf\b|getElementById|querySelector|JSON\.parse|substring|\.length\])/.test(
+      source
+    )) {
+      return findings;
+    }
+    const fileHasSwitch = /\bswitch\s*\(/.test(source);
+    for (let i = 0; i < lines.length; i++) {
+      this.checkAbort(signal);
+      const line = lines[i];
+      const lineNum = i + 1;
+      const stripped = stripLineForLogicScan(line);
+      if (/vibecheck:example/i.test(line) || /vibecheck:example/i.test(lines[i - 1] ?? "")) {
+        continue;
+      }
+      const masked = maskEqualityOps(stripped);
+      for (const hit of findLooseEqualityIssues(masked)) {
+        const evidence = line.trim().slice(0, 100);
+        findings.push(
+          this.createFinding({
+            id: this.deterministicId(uri, lineNum, hit.col, "LOGIC001", hit.op),
+            engine: "logic_gap",
+            ruleId: "LOGIC001",
+            category: "logic_gap",
+            message: `Use ${hit.op === "==" ? "===" : "!=="} instead of ${hit.op} to avoid coercion bugs`,
+            severity: "medium",
+            confidence: 0.88,
+            file: uri,
+            line: lineNum,
+            column: hit.col,
+            endLine: lineNum,
+            endColumn: hit.col + 2,
+            evidence,
+            suggestion: `Replace ${hit.op} with ${hit.op === "==" ? "===" : "!=="}. Keep == null only when intentionally matching null and undefined.`,
+            autoFixable: false
+          })
+        );
+      }
+      if (DOM_UNGUARDED_RE.test(stripped)) {
+        if (!/\)\s*[!?]\s*\./.test(line) && !/\)\s*as\s+/.test(line)) {
+          findings.push(
+            this.createFinding({
+              id: this.deterministicId(uri, lineNum, 0, "LOGIC002", "dom"),
+              engine: "logic_gap",
+              ruleId: "LOGIC002",
+              category: "logic_gap",
+              message: "Property access on querySelector/getElementById result without optional chaining \u2014 may be null",
+              severity: "high",
+              confidence: 0.68,
+              file: uri,
+              line: lineNum,
+              column: 0,
+              evidence: line.trim().slice(0, 100),
+              suggestion: "Use ?. , a null check, or a non-null assertion only when the element is guaranteed.",
+              autoFixable: false
+            })
+          );
+        }
+      } else if (JSON_PARSE_DOT_RE.test(stripped) && !lineHasOptionalBeforeJsonDot(line)) {
+        findings.push(
+          this.createFinding({
+            id: this.deterministicId(uri, lineNum, 0, "LOGIC002", "json"),
+            engine: "logic_gap",
+            ruleId: "LOGIC002",
+            category: "logic_gap",
+            message: "Property access on JSON.parse() result without validation or optional chaining",
+            severity: "high",
+            confidence: 0.62,
+            file: uri,
+            line: lineNum,
+            column: 0,
+            evidence: line.trim().slice(0, 100),
+            suggestion: "Validate with a schema (zod/io-ts), narrow the type, or use optional chaining.",
+            autoFixable: false
+          })
+        );
+      }
+      if (ARRAY_LENGTH_OOB_RE.test(stripped)) {
+        findings.push(
+          this.createFinding({
+            id: this.deterministicId(uri, lineNum, 0, "LOGIC004", "len"),
+            engine: "logic_gap",
+            ruleId: "LOGIC004",
+            category: "logic_gap",
+            message: "Reading array[array.length] is always undefined \u2014 likely off-by-one (use length - 1 or push)",
+            severity: "medium",
+            confidence: 0.68,
+            file: uri,
+            line: lineNum,
+            column: 0,
+            evidence: line.trim().slice(0, 100),
+            suggestion: "Use index array.length - 1 for the last element, or array.push(...) to append.",
+            autoFixable: false
+          })
+        );
+      }
+      if (SUBSTRING_SAME_ARGS_RE.test(stripped)) {
+        findings.push(
+          this.createFinding({
+            id: this.deterministicId(uri, lineNum, 0, "LOGIC004", "sub"),
+            engine: "logic_gap",
+            ruleId: "LOGIC004",
+            category: "logic_gap",
+            message: "substring(start, start) always yields an empty string \u2014 check indices",
+            severity: "low",
+            confidence: 0.58,
+            file: uri,
+            line: lineNum,
+            column: 0,
+            evidence: line.trim().slice(0, 100),
+            suggestion: "Verify both arguments; use slice if you need different semantics.",
+            autoFixable: false
+          })
+        );
+      }
+      const ctrl = stripped.match(
+        /^\s*(return\b[^;]*;\s*|throw\b[^;]*;\s*|break\s*;\s*|continue\s*;\s*)$/
+      );
+      if (ctrl) {
+        const ind = visualIndentLength(line);
+        for (let j = i + 1; j < lines.length; j++) {
+          const next = lines[j];
+          if (/vibecheck:example/i.test(next)) break;
+          const nt = stripLineForLogicScan(next);
+          if (!nt.trim()) continue;
+          if (/^\s*\/\//.test(next.trim())) {
+            if (/vibecheck:example/i.test(next)) break;
+            continue;
+          }
+          if (/^\s*\*/.test(next.trim())) continue;
+          const nj = visualIndentLength(next);
+          if (nj < ind) break;
+          if (nj > ind) continue;
+          const t = nt.trim();
+          if (/^case\b|^default\s*:/.test(t)) break;
+          if (t.startsWith("}")) break;
+          if (/^(else\b|catch\b|finally\b)/.test(t)) break;
+          findings.push(
+            this.createFinding({
+              id: this.deterministicId(uri, j + 1, 0, "LOGIC005", "unreachable"),
+              engine: "logic_gap",
+              ruleId: "LOGIC005",
+              category: "logic_gap",
+              message: "Unreachable code after return/throw/break/continue",
+              severity: "medium",
+              confidence: 0.74,
+              file: uri,
+              line: j + 1,
+              column: 0,
+              evidence: next.trim().slice(0, 100),
+              suggestion: "Remove dead code or fix control flow.",
+              autoFixable: false
+            })
+          );
+          break;
+        }
+      }
+      const assignCol = findAssignmentInConditional(stripped, "if") ?? findAssignmentInConditional(stripped, "while");
+      if (assignCol !== null) {
+        findings.push(
+          this.createFinding({
+            id: this.deterministicId(uri, lineNum, assignCol, "LOGIC006", "cond"),
+            engine: "logic_gap",
+            ruleId: "LOGIC006",
+            category: "logic_gap",
+            message: "Assignment inside if/while condition \u2014 often mistyped comparison (= vs ===)",
+            severity: "high",
+            confidence: 0.65,
+            file: uri,
+            line: lineNum,
+            column: assignCol,
+            evidence: line.trim().slice(0, 100),
+            suggestion: "If you meant comparison, use ===. If assignment is intentional, assign before the if/while.",
+            autoFixable: false
+          })
+        );
+      }
+      if (FLOAT_EQ_RE.test(stripped) && !/Number\.EPSILON|approx|tolerance|toBeCloseTo/i.test(line)) {
+        findings.push(
+          this.createFinding({
+            id: this.deterministicId(uri, lineNum, 0, "LOGIC007", "float"),
+            engine: "logic_gap",
+            ruleId: "LOGIC007",
+            category: "logic_gap",
+            message: "Direct equality check involving floating-point literals \u2014 precision risk",
+            severity: "medium",
+            confidence: 0.58,
+            file: uri,
+            line: lineNum,
+            column: 0,
+            evidence: line.trim().slice(0, 100),
+            suggestion: "Compare with a tolerance, use Number.EPSILON, or round before comparing.",
+            autoFixable: false
+          })
+        );
+      }
+      const falsyM = stripped.match(/\bif\s*\(\s*!\s*([a-zA-Z_$][\w$]*)\s*\)/);
+      if (falsyM && FALSY_NUMERIC_NAMES.test(falsyM[1])) {
+        findings.push(
+          this.createFinding({
+            id: this.deterministicId(uri, lineNum, 0, "LOGIC008", falsyM[1]),
+            engine: "logic_gap",
+            ruleId: "LOGIC008",
+            category: "logic_gap",
+            message: `Negated check on '${falsyM[1]}' \u2014 0 or "" are often valid for this name pattern`,
+            severity: "low",
+            confidence: 0.62,
+            file: uri,
+            line: lineNum,
+            column: 0,
+            evidence: line.trim().slice(0, 100),
+            suggestion: 'Prefer explicit checks: === 0, === "", or != null depending on intent.',
+            autoFixable: false
+          })
+        );
+      }
+      if (/(?:if|while)\s*\(/.test(stripped) && /\.indexOf\s*\(/.test(stripped)) {
+        if (/~\s*[^)]*\.indexOf|\.indexOf[^\n)]+\)\s*[-+*/]/.test(stripped)) ;
+        else if (/\.indexOf[^\n)]+\)\s*(?:!==|!=|===|==|>=|>|<=|<)/.test(stripped)) ;
+        else {
+          const im = stripped.match(/(?:if|while)\s*\(\s*([^)]*\.indexOf\s*\([^)]+\))\s*\)/);
+          if (im && !/!==|!=|===|==|>=|>|<=|</.test(im[1])) {
+            findings.push(
+              this.createFinding({
+                id: this.deterministicId(uri, lineNum, 0, "LOGIC011", "idx"),
+                engine: "logic_gap",
+                ruleId: "LOGIC011",
+                category: "logic_gap",
+                message: "indexOf(...) used as truthiness \u2014 -1 is truthy; use !== -1, >= 0, or .includes()",
+                severity: "high",
+                confidence: 0.72,
+                file: uri,
+                line: lineNum,
+                column: 0,
+                evidence: line.trim().slice(0, 100),
+                suggestion: "Rewrite as str.indexOf(x) !== -1 or str.includes(x).",
+                autoFixable: false
+              })
+            );
+          }
+        }
+      }
+      const optionalChainMatch012 = stripped.match(/(\w{3,})\?\.\w+/);
+      if (optionalChainMatch012) {
+        const ocVar = optionalChainMatch012[1];
+        if (/^(this|self|ctx|obj|res|req|err|ref|val)$/.test(ocVar)) ;
+        else {
+          for (let j = i + 1; j < Math.min(i + 8, lines.length); j++) {
+            const futureLine = lines[j];
+            if (/(?:function\s|=>\s*\{|\.then\s*\(|\.catch\s*\()/.test(futureLine)) break;
+            const futureStripped = stripLineForLogicScan(futureLine);
+            const unsafeAccess = new RegExp(`\\b${ocVar}\\.\\w+(?!\\?)`, "g");
+            if (unsafeAccess.test(futureStripped) && !new RegExp(`\\b${ocVar}\\?\\.`).test(futureStripped)) {
+              const guardPattern = new RegExp(`if\\s*\\(\\s*${ocVar}\\s*\\)`);
+              const hasGuard = lines.slice(i, j + 1).some((l) => guardPattern.test(l));
+              if (!hasGuard) {
+                findings.push(
+                  this.createFinding({
+                    id: this.deterministicId(uri, j + 1, 0, "LOGIC012", ocVar),
+                    engine: "logic_gap",
+                    ruleId: "LOGIC012",
+                    category: "logic_gap",
+                    message: `"${ocVar}" accessed with ?. on line ${lineNum} but without ?. here \u2014 inconsistent null safety`,
+                    severity: "medium",
+                    confidence: 0.6,
+                    file: uri,
+                    line: j + 1,
+                    column: 0,
+                    evidence: lines[j].trim().slice(0, 80),
+                    suggestion: `Use ${ocVar}?. consistently or add a null guard`,
+                    autoFixable: false
+                  })
+                );
+                break;
+              }
+            }
+          }
+        }
+      }
+      const arrBoundsMatch = stripped.match(/(\w+)\[(\w+)\.length\]/);
+      if (arrBoundsMatch && arrBoundsMatch[1] === arrBoundsMatch[2]) {
+        findings.push(
+          this.createFinding({
+            id: this.deterministicId(uri, lineNum, 0, "LOGIC013", arrBoundsMatch[1]),
+            engine: "logic_gap",
+            ruleId: "LOGIC013",
+            category: "logic_gap",
+            message: `${arrBoundsMatch[1]}[${arrBoundsMatch[2]}.length] is always out of bounds \u2014 arrays are 0-indexed`,
+            severity: "high",
+            confidence: 0.95,
+            file: uri,
+            line: lineNum,
+            column: 0,
+            evidence: stripped.trim().slice(0, 80),
+            suggestion: `Use ${arrBoundsMatch[1]}[${arrBoundsMatch[2]}.length - 1] for the last element`,
+            autoFixable: true
+          })
+        );
+      }
+      if (/typeof\s+\w+\s*===?\s*['"]object['"]/.test(stripped)) {
+        const hasNullCheck = /!==?\s*null|!= null/.test(stripped) || /\w+\s*&&\s*typeof/.test(stripped) || /&&\s*\w+\s*!==?\s*null/.test(stripped);
+        if (!hasNullCheck) {
+          findings.push(
+            this.createFinding({
+              id: this.deterministicId(uri, lineNum, 0, "LOGIC014", "typeof-null"),
+              engine: "logic_gap",
+              ruleId: "LOGIC014",
+              category: "logic_gap",
+              message: 'typeof x === "object" is true for null \u2014 add a null check',
+              severity: "medium",
+              confidence: 0.7,
+              file: uri,
+              line: lineNum,
+              column: 0,
+              evidence: stripped.trim().slice(0, 80),
+              suggestion: "Add && x !== null to exclude null from the object check",
+              autoFixable: false
+            })
+          );
+        }
+      }
+      if (/on\w+=\{async\s/.test(stripped) || /addEventListener\s*\(\s*['"][^'"]+['"]\s*,\s*async\s/.test(stripped)) {
+        findings.push(
+          this.createFinding({
+            id: this.deterministicId(uri, lineNum, 0, "LOGIC015", "async-void"),
+            engine: "logic_gap",
+            ruleId: "LOGIC015",
+            category: "logic_gap",
+            message: "Async event handler \u2014 unhandled rejections will be silently swallowed",
+            severity: "medium",
+            confidence: 0.7,
+            file: uri,
+            line: lineNum,
+            column: 0,
+            evidence: stripped.trim().slice(0, 80),
+            suggestion: "Wrap the async body in try/catch, or use a helper that catches and reports errors",
+            autoFixable: false
+          })
+        );
+      }
+    }
+    if (fileHasSwitch) {
+      this.checkAbort(signal);
+      const caseIndices = [];
+      for (let i = 0; i < lines.length; i++) {
+        if (caseLabelLeadingLength(lines[i])) caseIndices.push(i);
+      }
+      for (const caseIdx of caseIndices) {
+        this.checkAbort(signal);
+        const labelInfo = caseLabelLeadingLength(lines[caseIdx]);
+        if (!labelInfo) continue;
+        const labelIndent = labelInfo.indent;
+        let end = lines.length;
+        for (let j = caseIdx + 1; j < lines.length; j++) {
+          const cl = caseLabelLeadingLength(lines[j]);
+          if (cl && cl.indent === labelIndent) {
+            end = j;
+            break;
+          }
+          const raw = lines[j];
+          if (/^\s*\}\s*$/.test(raw) && visualIndentLength(raw) < labelIndent) {
+            end = j;
+            break;
+          }
+        }
+        const segmentLines = lines.slice(caseIdx + 1, end);
+        if (segmentLines.length === 0) continue;
+        const rawSeg = segmentLines.join("\n");
+        const strippedSeg = segmentLines.map((l) => stripLineForLogicScan(l)).join("\n");
+        if (!strippedSeg.trim()) continue;
+        if (segmentHasFallthroughComment(rawSeg) || segmentHasFallthroughComment(strippedSeg)) continue;
+        if (segmentHasExitStatement(strippedSeg)) continue;
+        const lastNonEmpty = (() => {
+          for (let j = segmentLines.length - 1; j >= 0; j--) {
+            if (stripLineForLogicScan(segmentLines[j]).trim()) return caseIdx + 1 + j + 1;
+          }
+          return caseIdx + 1;
+        })();
+        findings.push(
+          this.createFinding({
+            id: this.deterministicId(uri, lastNonEmpty, 0, "LOGIC010", `case-${caseIdx}`),
+            engine: "logic_gap",
+            ruleId: "LOGIC010",
+            category: "logic_gap",
+            message: "Switch case falls through without break/return \u2014 add break or document intentional fallthrough",
+            severity: "medium",
+            confidence: 0.67,
+            file: uri,
+            line: lastNonEmpty,
+            column: 0,
+            evidence: lines[lastNonEmpty - 1].trim().slice(0, 100),
+            suggestion: 'Add break;, return, or throw \u2014 or a comment such as "fallthrough" if merging cases intentionally.',
+            autoFixable: false
+          })
+        );
+      }
+    }
+    return findings;
+  }
+};
+
+export { LogicGapEngine };