@noctcore/eslint-plugin-code-quality 0.1.0

package/dist/index.js

@@ -0,0 +1,697 @@
+// src/configs/recommended.ts
+var recommended = {
+  "noctcore-code-quality/prefer-early-return": "error",
+  "noctcore-code-quality/no-process-exit": "error",
+  "noctcore-code-quality/no-bare-date-now": "error",
+  "noctcore-code-quality/no-historical-comments": "error",
+  "noctcore-code-quality/no-narration-comments": "error",
+  "noctcore-code-quality/no-pr-reference-comments": "error",
+  "noctcore-code-quality/no-focused-tests": "error",
+  "noctcore-code-quality/skipped-tests-need-tracking": "error"
+};
+
+// src/rules/interface-prefix-i.ts
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+
+// src/createRule.ts
+import { makeCreateRule } from "@noctcore/eslint-utils";
+var createRule = makeCreateRule("code-quality");
+
+// src/rules/interface-prefix-i.ts
+var RULE_NAME = "interface-prefix-i";
+function isAlreadyPrefixed(name) {
+  return /^I[A-Z]/.test(name);
+}
+function isInsideAmbientModule(node) {
+  let current = node.parent;
+  while (current) {
+    if (current.type === AST_NODE_TYPES.TSModuleDeclaration) {
+      return true;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+var interfacePrefixIRule = createRule({
+  name: RULE_NAME,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Interface names must be prefixed with `I` followed by an uppercase letter. Module/global augmentations are exempt."
+    },
+    schema: [],
+    messages: {
+      missingPrefix: "Interface `{{name}}` must be prefixed with `I` (e.g. `I{{name}}`). Rename the declaration and its references."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      TSInterfaceDeclaration(node) {
+        const name = node.id.name;
+        if (isAlreadyPrefixed(name) || isInsideAmbientModule(node)) {
+          return;
+        }
+        context.report({ node: node.id, messageId: "missingPrefix", data: { name } });
+      }
+    };
+  }
+});
+
+// src/rules/no-bare-date-now.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES2 } from "@typescript-eslint/utils";
+
+// src/utils/allowMatch.ts
+var REGEX_METACHARACTERS = /[.*+?^${}()|[\]\\]/gu;
+function escapeLiteral(text) {
+  return text.replace(REGEX_METACHARACTERS, "\\$&");
+}
+function globToRegExp(glob) {
+  let source = "";
+  let i = 0;
+  while (i < glob.length) {
+    const char = glob[i];
+    if (char === void 0) {
+      break;
+    }
+    if (char === "*") {
+      if (glob[i + 1] === "*") {
+        i += 2;
+        if (glob[i] === "/") {
+          source += "(?:.*/)?";
+          i += 1;
+        } else {
+          source += ".*";
+        }
+      } else {
+        source += "[^/]*";
+        i += 1;
+      }
+    } else if (char === "?") {
+      source += "[^/]";
+      i += 1;
+    } else if (char === "{") {
+      const end = glob.indexOf("}", i);
+      if (end === -1) {
+        source += "\\{";
+        i += 1;
+      } else {
+        const alternatives = glob.slice(i + 1, end).split(",").map(escapeLiteral).join("|");
+        source += `(?:${alternatives})`;
+        i = end + 1;
+      }
+    } else {
+      source += escapeLiteral(char);
+      i += 1;
+    }
+  }
+  return new RegExp(`^${source}$`, "u");
+}
+var compiledCache = /* @__PURE__ */ new Map();
+function compile(glob) {
+  const cached = compiledCache.get(glob);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const regex = globToRegExp(glob);
+  compiledCache.set(glob, regex);
+  return regex;
+}
+function matchesAny(filename, globs) {
+  if (globs.length === 0) {
+    return false;
+  }
+  const normalized = filename.split("\\").join("/");
+  return globs.some((glob) => compile(glob).test(normalized));
+}
+
+// src/rules/no-bare-date-now.ts
+var RULE_NAME2 = "no-bare-date-now";
+var DEFAULT_ALLOW_IN = ["**/clock.ts", "**/clock/**"];
+var optionSchema = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    allowIn: {
+      type: "array",
+      items: { type: "string" },
+      uniqueItems: true
+    }
+  }
+};
+function isDateNowCall(node) {
+  const callee = node.callee;
+  return callee.type === AST_NODE_TYPES2.MemberExpression && !callee.computed && callee.object.type === AST_NODE_TYPES2.Identifier && callee.object.name === "Date" && callee.property.type === AST_NODE_TYPES2.Identifier && callee.property.name === "now";
+}
+function isBareNewDate(node) {
+  return node.callee.type === AST_NODE_TYPES2.Identifier && node.callee.name === "Date" && node.arguments.length === 0;
+}
+var noBareDateNowRule = createRule({
+  name: RULE_NAME2,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow bare `Date.now()` / `new Date()` in business logic. Read wall-clock time through a shared `clock` util (`nowMs()` / `now()`) so time is mockable."
+    },
+    schema: [optionSchema],
+    messages: {
+      dateNow: "Use `nowMs()` from the shared `clock` util instead of bare `Date.now()`.",
+      newDate: "Use `now()` from the shared `clock` util instead of bare `new Date()`."
+    }
+  },
+  defaultOptions: [{ allowIn: [...DEFAULT_ALLOW_IN] }],
+  create(context, [options]) {
+    const allowIn = options.allowIn ?? DEFAULT_ALLOW_IN;
+    if (matchesAny(context.filename, allowIn)) {
+      return {};
+    }
+    return {
+      CallExpression(node) {
+        if (isDateNowCall(node)) {
+          context.report({ node, messageId: "dateNow" });
+        }
+      },
+      NewExpression(node) {
+        if (isBareNewDate(node)) {
+          context.report({ node, messageId: "newDate" });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-focused-tests.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES3 } from "@typescript-eslint/utils";
+var RULE_NAME3 = "no-focused-tests";
+var FOCUSABLE_RUNNERS = /* @__PURE__ */ new Set(["it", "describe", "test"]);
+var FOCUSED_CALL_NAMES = /* @__PURE__ */ new Set(["fdescribe", "fit", "ddescribe"]);
+function rootRunnerName(node) {
+  let current = node;
+  while (current.type === AST_NODE_TYPES3.MemberExpression && !current.computed) {
+    current = current.object;
+  }
+  return current.type === AST_NODE_TYPES3.Identifier ? current.name : null;
+}
+var noFocusedTestsRule = createRule({
+  name: RULE_NAME3,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Ban focused tests (it.only / describe.only / test.only, fdescribe / fit / ddescribe) so a focused test never silently lands in CI."
+    },
+    schema: [],
+    messages: {
+      focused: "Focused test: remove `.only` from `{{runner}}.only(...)` so the whole suite runs in CI.",
+      focusedCall: "Focused test: replace `{{name}}(...)` with `{{base}}(...)` so the whole suite runs in CI."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      MemberExpression(node) {
+        if (node.property.type !== AST_NODE_TYPES3.Identifier || node.property.name !== "only") {
+          return;
+        }
+        const runner = rootRunnerName(node.object);
+        if (runner !== null && FOCUSABLE_RUNNERS.has(runner)) {
+          context.report({
+            node: node.property,
+            messageId: "focused",
+            data: { runner }
+          });
+        }
+      },
+      CallExpression(node) {
+        if (node.callee.type === AST_NODE_TYPES3.Identifier && FOCUSED_CALL_NAMES.has(node.callee.name)) {
+          const name = node.callee.name;
+          context.report({
+            node: node.callee,
+            messageId: "focusedCall",
+            data: { name, base: name.startsWith("f") ? name.slice(1) : "describe" }
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/utils/comments.ts
+function commentText(comment) {
+  if (comment.type === "Line") {
+    return comment.value.trim();
+  }
+  return comment.value.split("\n").map((line) => line.replace(/^\s*\*?/u, "")).join(" ").trim();
+}
+function looksLikeJsDoc(comment) {
+  return comment.type === "Block" && comment.value.startsWith("*");
+}
+
+// src/rules/no-historical-comments.ts
+var RULE_NAME4 = "no-historical-comments";
+var HISTORICAL_PATTERNS = [
+  /\bbefore\s+the\s+fix\b/iu,
+  /\bafter\s+the\s+fix\b/iu,
+  /\bbefore\s+the\s+refactor\b/iu,
+  /\bafter\s+the\s+refactor\b/iu,
+  /\bwe\s+used\s+to\b/iu,
+  /\bthis\s+used\s+to\b/iu,
+  /\bused\s+to\s+be\b/iu,
+  /\bno\s+longer\b/iu,
+  /\bkept\s+for\s+(?:backwards|backward|legacy|compat)\b/iu,
+  /\b(?:was|were)\s+a\s+(?:footgun|bug)\b/iu,
+  /\bhistorical(?:ly)?\b/iu
+];
+var noHistoricalCommentsRule = createRule({
+  name: RULE_NAME4,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow comments that frame code relative to what it used to do or to a past incident ('before the fix', 'after the refactor', 'we used to', 'no longer'). Source comments describe the current invariant; history belongs in the commit message or PR description, where it does not rot when the code changes again."
+    },
+    schema: [],
+    messages: {
+      historicalComment: "Historical narration ({{snippet}}). Source comments describe the current invariant, not what the code used to do. Move the history to the commit message or delete the comment."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      Program() {
+        for (const comment of context.sourceCode.getAllComments()) {
+          if (looksLikeJsDoc(comment)) {
+            continue;
+          }
+          const text = commentText(comment);
+          if (text === "") {
+            continue;
+          }
+          for (const pattern of HISTORICAL_PATTERNS) {
+            const match = pattern.exec(text);
+            if (match !== null) {
+              const matched = match[0];
+              const snippet = matched.length > 40 ? `${matched.slice(0, 40)}...` : matched;
+              context.report({
+                loc: comment.loc,
+                messageId: "historicalComment",
+                data: { snippet }
+              });
+              break;
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-narration-comments.ts
+var RULE_NAME5 = "no-narration-comments";
+var NARRATION_PATTERNS = [
+  /^here\s+we\b/iu,
+  /^now\s+we\b/iu,
+  /^first[,]?\s+we\b/iu,
+  /^then[,]?\s+we\b/iu,
+  /^next[,]?\s+we\b/iu,
+  /^finally[,]?\s+we\b/iu,
+  /^let's\b/iu,
+  /^let\s+me\b/iu
+];
+var noNarrationCommentsRule = createRule({
+  name: RULE_NAME5,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow narrative comments like 'Here we...', 'Now we...', 'First, we...'. These read as step-by-step prose and add no information a future reader cannot get from the code itself. Often a tell that the comment was generated by an agent describing its own changes."
+    },
+    schema: [],
+    messages: {
+      narrationComment: "Narrative comment ({{snippet}}). Describe the WHY, not the sequence of operations, or delete the comment."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      Program() {
+        for (const comment of context.sourceCode.getAllComments()) {
+          if (looksLikeJsDoc(comment)) {
+            continue;
+          }
+          const text = commentText(comment);
+          if (text === "") {
+            continue;
+          }
+          for (const pattern of NARRATION_PATTERNS) {
+            if (pattern.test(text)) {
+              const snippet = text.length > 40 ? `${text.slice(0, 40)}...` : text;
+              context.report({
+                loc: comment.loc,
+                messageId: "narrationComment",
+                data: { snippet }
+              });
+              break;
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-pr-reference-comments.ts
+var RULE_NAME6 = "no-pr-reference-comments";
+var PR_PATTERNS = [
+  {
+    pattern: /https?:\/\/github\.com\/[^\s)]+\/(?:pull|issues)\/\d+/iu,
+    label: "GitHub PR/issue URL"
+  },
+  {
+    pattern: /\b(?:see|closes?|fixes|fixed|addresses|resolves?|refs?)\s+#\d+/iu,
+    label: "issue/PR reference"
+  },
+  {
+    pattern: /\bPRs?\s+#?\d+/iu,
+    label: "PR number"
+  },
+  {
+    pattern: /(?:^|[\s(])#\d+\b/u,
+    label: "issue/PR number"
+  }
+];
+var noPrReferenceCommentsRule = createRule({
+  name: RULE_NAME6,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow PR/issue references in comments. They belong in commit messages and PR descriptions, where they do not rot when the repo moves, the issue tracker migrates, or the numbering changes."
+    },
+    schema: [],
+    messages: {
+      prReferenceComment: "Comment contains {{label}} ({{snippet}}). Move it to the commit message or PR description. The git log is the canonical place for repo-history references."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      Program() {
+        for (const comment of context.sourceCode.getAllComments()) {
+          const text = comment.value;
+          if (text.trim() === "") {
+            continue;
+          }
+          for (const { pattern, label } of PR_PATTERNS) {
+            const match = pattern.exec(text);
+            if (match === null) {
+              continue;
+            }
+            const matched = match[0].trim();
+            const snippet = matched.length > 40 ? `${matched.slice(0, 40)}...` : matched;
+            context.report({
+              loc: comment.loc,
+              messageId: "prReferenceComment",
+              data: { label, snippet }
+            });
+            break;
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-process-exit.ts
+import "@typescript-eslint/utils";
+
+// src/utils/ast.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES4 } from "@typescript-eslint/utils";
+function isEmptyStringLiteral(node) {
+  return node.type === AST_NODE_TYPES4.Literal && node.value === "";
+}
+function isStaticMemberAccess(node, objectName, propertyName) {
+  if (node.type !== AST_NODE_TYPES4.MemberExpression || node.object.type !== AST_NODE_TYPES4.Identifier || node.object.name !== objectName) {
+    return false;
+  }
+  if (node.computed) {
+    return node.property.type === AST_NODE_TYPES4.Literal && node.property.value === propertyName;
+  }
+  return node.property.type === AST_NODE_TYPES4.Identifier && node.property.name === propertyName;
+}
+
+// src/rules/no-process-exit.ts
+var RULE_NAME7 = "no-process-exit";
+var DEFAULT_ALLOW_IN2 = [
+  "**/scripts/**",
+  "**/bin/**",
+  "**/cli/**",
+  "**/*.config.{ts,js,mjs,cjs,cts,mts}"
+];
+var optionSchema2 = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    allowIn: {
+      type: "array",
+      items: { type: "string" },
+      uniqueItems: true
+    }
+  }
+};
+function isProcessExit(node) {
+  return isStaticMemberAccess(node.callee, "process", "exit");
+}
+var noProcessExitRule = createRule({
+  name: RULE_NAME7,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow `process.exit()` outside bootstrap/shutdown paths and standalone CLIs. Application and service code must throw or reject so the lifecycle can shut down gracefully."
+    },
+    schema: [optionSchema2],
+    messages: {
+      processExit: "`process.exit()` is reserved for bootstrap/shutdown and CLI entrypoints. Throw or reject and let the lifecycle handle teardown."
+    }
+  },
+  defaultOptions: [{ allowIn: [...DEFAULT_ALLOW_IN2] }],
+  create(context, [options]) {
+    const allowIn = options.allowIn ?? DEFAULT_ALLOW_IN2;
+    if (matchesAny(context.filename, allowIn)) {
+      return {};
+    }
+    return {
+      CallExpression(node) {
+        if (isProcessExit(node)) {
+          context.report({ node, messageId: "processExit" });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-template-trim-empty-ternary.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES5 } from "@typescript-eslint/utils";
+var RULE_NAME8 = "no-template-trim-empty-ternary";
+function isTrimCallOnTemplate(node) {
+  return node.type === AST_NODE_TYPES5.CallExpression && node.callee.type === AST_NODE_TYPES5.MemberExpression && node.callee.property.type === AST_NODE_TYPES5.Identifier && node.callee.property.name === "trim" && node.callee.object.type === AST_NODE_TYPES5.TemplateLiteral;
+}
+function matchesTemplateTrimEmptyTest(test) {
+  if (test.type !== AST_NODE_TYPES5.BinaryExpression) {
+    return false;
+  }
+  if (test.operator !== "===" && test.operator !== "!==") {
+    return false;
+  }
+  return isTrimCallOnTemplate(test.left) && isEmptyStringLiteral(test.right) || isEmptyStringLiteral(test.left) && isTrimCallOnTemplate(test.right);
+}
+var noTemplateTrimEmptyTernaryRule = createRule({
+  name: RULE_NAME8,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow inline `<template>.trim() === '' ? fallback : <template>.trim()` patterns. Extract to a named utility so the expression is built once and is unit-testable in one place."
+    },
+    schema: [],
+    messages: {
+      extractToUtil: "Extract this `<template>.trim() === ''` fallback pattern to a named util (e.g. `buildDisplayName(...)`). The inline ternary builds the same expression twice and is not unit-testable in one place."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      ConditionalExpression(node) {
+        if (matchesTemplateTrimEmptyTest(node.test)) {
+          context.report({ node, messageId: "extractToUtil" });
+        }
+      }
+    };
+  }
+});
+
+// src/utils/preferEarlyReturn.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES6 } from "@typescript-eslint/utils";
+var MIN_CONSEQUENT_STATEMENTS = 2;
+function getFunctionBlockBody(node) {
+  if (node.body.type !== AST_NODE_TYPES6.BlockStatement) {
+    return null;
+  }
+  return node.body;
+}
+function findWrappedHappyPathIf(body) {
+  if (body.body.length === 0) {
+    return null;
+  }
+  const lastStatement = body.body[body.body.length - 1];
+  if (lastStatement === void 0 || lastStatement.type !== AST_NODE_TYPES6.IfStatement) {
+    return null;
+  }
+  if (lastStatement.alternate !== null) {
+    return null;
+  }
+  if (lastStatement.consequent.type !== AST_NODE_TYPES6.BlockStatement) {
+    return null;
+  }
+  if (lastStatement.consequent.body.length < MIN_CONSEQUENT_STATEMENTS) {
+    return null;
+  }
+  return lastStatement;
+}
+
+// src/rules/prefer-early-return.ts
+var RULE_NAME9 = "prefer-early-return";
+var preferEarlyReturnRule = createRule({
+  name: RULE_NAME9,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Prefer guard clauses (early return) over wrapping the whole function body in a multi-statement `if` without an `else`."
+    },
+    schema: [],
+    messages: {
+      preferEarlyReturn: "Use a guard clause (early return) instead of wrapping the function body in an `if`. Invert the condition and return early so the happy path stays at the top level."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    function checkFunctionBody(node) {
+      const body = getFunctionBlockBody(node);
+      if (body === null) {
+        return;
+      }
+      const wrappedIf = findWrappedHappyPathIf(body);
+      if (wrappedIf !== null) {
+        context.report({ node: wrappedIf, messageId: "preferEarlyReturn" });
+      }
+    }
+    return {
+      FunctionDeclaration: checkFunctionBody,
+      FunctionExpression: checkFunctionBody,
+      ArrowFunctionExpression: checkFunctionBody
+    };
+  }
+});
+
+// src/rules/skipped-tests-need-tracking.ts
+var RULE_NAME10 = "skipped-tests-need-tracking";
+var SKIP_PATTERNS = [
+  { pattern: /\b(?:it|test|describe)\.skip\s*\(/u, label: ".skip(" },
+  { pattern: /\b(?:it|test|describe)\.fixme\s*\(/u, label: ".fixme(" },
+  { pattern: /\bxit\s*\(/u, label: "xit(" },
+  { pattern: /\bxdescribe\s*\(/u, label: "xdescribe(" },
+  { pattern: /\bxtest\s*\(/u, label: "xtest(" }
+];
+var DEFAULT_MARKERS = ["https?://\\S+", "TODO\\(@?\\S+\\)"];
+var DEFAULT_LOOKBACK = 30;
+var optionSchema3 = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    markers: {
+      type: "array",
+      items: { type: "string" },
+      uniqueItems: true,
+      minItems: 1
+    },
+    lookback: { type: "integer", minimum: 0 }
+  }
+};
+var skippedTestsNeedTrackingRule = createRule({
+  name: RULE_NAME10,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Skipped tests (`.skip` / `.fixme` / `xit` / `xdescribe`) must carry a tracking marker (an issue URL or `TODO(@owner)`) on or above the line, so the debt has an owner instead of rotting silently."
+    },
+    schema: [optionSchema3],
+    messages: {
+      needsTracking: "Skipped test `{{label}}` has no tracking marker. Add an issue URL or `TODO(@owner)` on the same line or above so the skip has an owner."
+    }
+  },
+  defaultOptions: [{ markers: [...DEFAULT_MARKERS], lookback: DEFAULT_LOOKBACK }],
+  create(context, [options]) {
+    const markerSources = options.markers ?? DEFAULT_MARKERS;
+    const markers = markerSources.map((source) => new RegExp(source, "u"));
+    const lookback = options.lookback ?? DEFAULT_LOOKBACK;
+    const lines = context.sourceCode.lines;
+    function hasTrackingMarker(fromLine, toLine) {
+      const window = lines.slice(fromLine, toLine + 1).join("\n");
+      return markers.some((marker) => marker.test(window));
+    }
+    return {
+      Program() {
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i] ?? "";
+          for (const { pattern, label } of SKIP_PATTERNS) {
+            if (!pattern.test(line)) {
+              continue;
+            }
+            const start = Math.max(0, i - lookback);
+            if (hasTrackingMarker(start, i)) {
+              continue;
+            }
+            context.report({
+              loc: {
+                start: { line: i + 1, column: 0 },
+                end: { line: i + 1, column: line.length }
+              },
+              messageId: "needsTracking",
+              data: { label }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/index.ts
+var rules = {
+  "prefer-early-return": preferEarlyReturnRule,
+  "no-process-exit": noProcessExitRule,
+  "no-bare-date-now": noBareDateNowRule,
+  "no-historical-comments": noHistoricalCommentsRule,
+  "no-narration-comments": noNarrationCommentsRule,
+  "no-pr-reference-comments": noPrReferenceCommentsRule,
+  "no-focused-tests": noFocusedTestsRule,
+  "skipped-tests-need-tracking": skippedTestsNeedTrackingRule,
+  // Available but omitted from `recommended` (opinionated / niche).
+  "interface-prefix-i": interfacePrefixIRule,
+  "no-template-trim-empty-ternary": noTemplateTrimEmptyTernaryRule
+};
+
+// src/index.ts
+var NAMESPACE = "noctcore-code-quality";
+var VERSION = "0.1.0";
+var plugin = {
+  meta: { name: "@noctcore/eslint-plugin-code-quality", version: VERSION },
+  rules,
+  configs: {}
+};
+plugin.configs.recommended = {
+  plugins: { [NAMESPACE]: plugin },
+  rules: recommended
+};
+var configs = plugin.configs;
+var index_default = plugin;
+export {
+  configs,
+  index_default as default,
+  rules
+};