eslint-plugin-ai-guard 1.1.13 → 1.2.0

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -28,7 +38,7 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/rules/error-handling/no-empty-catch.ts
+// src/rules/reliability/no-empty-catch.ts
 var import_utils = require("@typescript-eslint/utils");
 var createRule = import_utils.ESLintUtils.RuleCreator(
   (name) => `https://github.com/YashJadhav21/eslint-plugin-ai-guard/blob/main/docs/rules/${name}.md`
@@ -75,7 +85,7 @@ var noEmptyCatch = createRule({
   }
 });
 
-// src/rules/error-handling/no-broad-exception.ts
+// src/rules/reliability/no-broad-exception.ts
 var import_utils2 = require("@typescript-eslint/utils");
 var createRule2 = import_utils2.ESLintUtils.RuleCreator(
   (name) => `https://github.com/YashJadhav21/eslint-plugin-ai-guard/blob/main/docs/rules/${name}.md`
@@ -152,7 +162,7 @@ function containsInstanceofCheck(node, paramName) {
   return false;
 }
 
-// src/rules/error-handling/no-catch-log-rethrow.ts
+// src/rules/reliability/no-catch-log-rethrow.ts
 var import_utils3 = require("@typescript-eslint/utils");
 var createRule3 = import_utils3.ESLintUtils.RuleCreator(
   (name) => `https://github.com/YashJadhav21/eslint-plugin-ai-guard/blob/main/docs/rules/${name}.md`
@@ -214,7 +224,7 @@ var noCatchLogRethrow = createRule3({
   }
 });
 
-// src/rules/error-handling/no-catch-without-use.ts
+// src/rules/reliability/no-catch-without-use.ts
 var import_utils4 = require("@typescript-eslint/utils");
 var createRule4 = import_utils4.ESLintUtils.RuleCreator(
   (name) => `https://github.com/YashJadhav21/eslint-plugin-ai-guard/blob/main/docs/rules/${name}.md`
@@ -648,6 +658,7 @@ var noFloatingPromise = createRule6({
 
 // src/rules/async/no-await-in-loop.ts
 var import_utils7 = require("@typescript-eslint/utils");
+var import_path = __toESM(require("path"));
 var createRule7 = import_utils7.ESLintUtils.RuleCreator(
   (name) => `https://github.com/YashJadhav21/eslint-plugin-ai-guard/blob/main/docs/rules/${name}.md`
 );
@@ -661,6 +672,7 @@ var LOOP_TYPES = /* @__PURE__ */ new Set([
 var SUPPRESSION_REGEX = /ai-guard-disable\s+no-await-in-loop\b/i;
 var RETRY_NAME_REGEX = /(retry|retries|attempt|attempts|fallback|tryagain|recovery)/i;
 var SEQUENTIAL_DEPENDENCY_NAME_REGEX = /(previous|prev|last|carry|accumulator|stateful)/i;
+var SIMULATION_NAME_REGEX = /(simulat|animat|demo|visuali|step|scene|frame|render|tick|sequence|tutorial|lesson|walk)/i;
 var ERROR_CODE_HINTS = [
   "access-denied",
   "timeout",
@@ -675,6 +687,15 @@ var CONTROL_AWAIT_HINTS = [
   "ratelimit",
   "backoff"
 ];
+var TIMER_FUNCTION_NAMES = /* @__PURE__ */ new Set([
+  "setinterval",
+  "settimeout",
+  "requestanimationframe",
+  "queuemicrotask",
+  "sleep",
+  "delay",
+  "wait"
+]);
 var MUTATION_METHOD_NAMES = /* @__PURE__ */ new Set([
   "push",
   "pop",
@@ -875,6 +896,9 @@ function analyzeIntent(loopNode) {
     if (SEQUENTIAL_DEPENDENCY_NAME_REGEX.test(name)) {
       hasSequentialDependency = true;
     }
+    if (SIMULATION_NAME_REGEX.test(name)) {
+      hasSequentialDependency = true;
+    }
   };
   walkNode(
     loopNode,
@@ -889,6 +913,9 @@ function analyzeIntent(loopNode) {
           if (CONTROL_AWAIT_HINTS.some((hint) => lower.includes(hint))) {
             hasControlAwait = true;
           }
+          if (TIMER_FUNCTION_NAMES.has(lower)) {
+            hasControlAwait = true;
+          }
         }
       }
       if (node.type === import_utils7.AST_NODE_TYPES.UpdateExpression) {
@@ -1025,16 +1052,43 @@ var noAwaitInLoop = createRule7({
       description: "Disallow independent `await` usage inside loops, while allowing intentional retry/fallback/sequential workflows. AI tools frequently generate accidental sequential awaits where Promise.all would be safer and faster. Includes a safe autofix for simple independent loops."
     },
     fixable: "code",
-    schema: [],
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allowPatterns: {
+            type: "array",
+            items: { type: "string" },
+            description: "File glob patterns to skip (e.g., **/*.test.ts, **/simulation/**)"
+          }
+        },
+        additionalProperties: false
+      }
+    ],
     messages: {
-      awaitInLoop: "Unexpected `await` inside a {{loopType}}. AI tools frequently generate sequential awaits in loops, causing O(n) latency. Consider collecting promises and using `Promise.all()` for parallel execution."
+      awaitInLoop: "Sequential `await` inside a {{loopType}} \u2014 if these items are independent, consider `Promise.all()` for parallel execution. If sequential order matters, this may be intentional."
     }
   },
-  defaultOptions: [],
-  create(context) {
+  defaultOptions: [{}],
+  create(context, [options]) {
     if (hasFileSuppression(context.sourceCode)) {
       return {};
     }
+    const filename = context.filename ?? context.getFilename?.() ?? "";
+    const fileBasename = import_path.default.basename(filename).toLowerCase();
+    const filePath = filename.toLowerCase();
+    const isTestFile = fileBasename.includes(".test.") || fileBasename.includes(".spec.") || filePath.includes("/__tests__/") || filePath.includes("/test/") || filePath.includes("/tests/");
+    const isSimulationFile = SIMULATION_NAME_REGEX.test(fileBasename) || filePath.includes("/simulation/") || filePath.includes("/demo/") || filePath.includes("/animation/") || filePath.includes("/fixtures/");
+    if (isTestFile || isSimulationFile) {
+      return {};
+    }
+    const { allowPatterns = [] } = options;
+    for (const pattern of allowPatterns) {
+      const cleaned = pattern.replace(/\*\*/g, "").replace(/\*/g, "").replace(/\//g, import_path.default.sep);
+      if (cleaned && filePath.includes(cleaned.toLowerCase())) {
+        return {};
+      }
+    }
     const loopIntentCache = /* @__PURE__ */ new WeakMap();
     const reportedLoops = /* @__PURE__ */ new WeakSet();
     const functionBoundary = [];
@@ -1095,9 +1149,36 @@ var noAwaitInLoop = createRule7({
 
 // src/rules/async/no-async-without-await.ts
 var import_utils8 = require("@typescript-eslint/utils");
+var import_path2 = __toESM(require("path"));
 var createRule8 = import_utils8.ESLintUtils.RuleCreator(
   (name) => `https://github.com/YashJadhav21/eslint-plugin-ai-guard/blob/main/docs/rules/${name}.md`
 );
+var FRAMEWORK_FILE_PATTERNS = [
+  // Next.js App Router
+  /[/\\]route\.(ts|js|tsx|jsx)$/,
+  /[/\\]middleware\.(ts|js)$/,
+  /[/\\]layout\.(tsx|jsx|ts|js)$/,
+  /[/\\]page\.(tsx|jsx|ts|js)$/,
+  /[/\\]loading\.(tsx|jsx|ts|js)$/,
+  /[/\\]error\.(tsx|jsx|ts|js)$/,
+  /[/\\]not-found\.(tsx|jsx|ts|js)$/,
+  /[/\\]template\.(tsx|jsx|ts|js)$/,
+  // Next.js Pages Router conventions
+  /[/\\]_app\.(tsx|jsx)$/,
+  /[/\\]_document\.(tsx|jsx)$/
+];
+var HTTP_METHOD_EXPORTS = /* @__PURE__ */ new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS"
+]);
+var REACT_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".tsx", ".jsx"]);
+var HANDLER_NAME_REGEX = /^(handle|on[A-Z])/;
+var MIDDLEWARE_NAME_REGEX = /^(use[A-Z]|middleware|interceptor|guard|beforeEach|afterEach)/;
 function containsAwaitExpression(node) {
   if (node.type === import_utils8.AST_NODE_TYPES.AwaitExpression) {
     return true;
@@ -1131,21 +1212,101 @@ function containsAwaitExpression(node) {
   }
   return false;
 }
+function isPassThroughWrapper(node) {
+  if (node.body.type !== import_utils8.AST_NODE_TYPES.BlockStatement) {
+    const body = node.body;
+    if (body.type === import_utils8.AST_NODE_TYPES.CallExpression || body.type === import_utils8.AST_NODE_TYPES.MemberExpression) {
+      return true;
+    }
+    return false;
+  }
+  if (node.body.body.length !== 1) return false;
+  const only = node.body.body[0];
+  if (only.type !== import_utils8.AST_NODE_TYPES.ReturnStatement) return false;
+  if (!only.argument) return false;
+  return only.argument.type === import_utils8.AST_NODE_TYPES.CallExpression;
+}
+function isFunctionExportedWithHttpMethodName(node) {
+  if (node.type === import_utils8.AST_NODE_TYPES.FunctionDeclaration && node.id) {
+    return HTTP_METHOD_EXPORTS.has(node.id.name);
+  }
+  if (node.parent?.type === import_utils8.AST_NODE_TYPES.VariableDeclarator) {
+    const declarator = node.parent;
+    if (declarator.id.type === import_utils8.AST_NODE_TYPES.Identifier && HTTP_METHOD_EXPORTS.has(declarator.id.name)) {
+      return true;
+    }
+  }
+  return false;
+}
+function getFunctionName(node) {
+  if (node.type === import_utils8.AST_NODE_TYPES.FunctionDeclaration && node.id) {
+    return node.id.name;
+  }
+  if (node.parent?.type === import_utils8.AST_NODE_TYPES.VariableDeclarator) {
+    const declarator = node.parent;
+    if (declarator.id.type === import_utils8.AST_NODE_TYPES.Identifier) {
+      return declarator.id.name;
+    }
+  }
+  if (node.parent?.type === import_utils8.AST_NODE_TYPES.Property || node.parent?.type === import_utils8.AST_NODE_TYPES.MethodDefinition) {
+    const parent = node.parent;
+    if ("key" in parent && parent.key.type === import_utils8.AST_NODE_TYPES.Identifier) {
+      return parent.key.name;
+    }
+  }
+  return null;
+}
 var noAsyncWithoutAwait = createRule8({
   name: "no-async-without-await",
   meta: {
     type: "suggestion",
     docs: {
-      description: "Disallow async functions that never use await. AI tools frequently add async by default, creating misleading signatures and unnecessary Promise wrappers. Includes a safe autofix for simple function bodies."
+      description: "Disallow async functions that never use await. AI tools frequently add async by default, creating misleading signatures and unnecessary Promise wrappers. Framework-specific async conventions (Next.js route handlers, React event handlers) are excluded."
     },
     fixable: "code",
-    schema: [],
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allowedFunctionNames: {
+            type: "array",
+            items: { type: "string" },
+            description: "Additional function names to skip (on top of HTTP methods)"
+          },
+          frameworkFiles: {
+            type: "array",
+            items: { type: "string" },
+            description: "Additional file glob patterns where async-without-await is allowed"
+          },
+          ignorePassThroughWrappers: {
+            type: "boolean",
+            description: "Downgrade (not suppress) pass-through wrappers. Default: true."
+          },
+          ignoreHandlerFunctions: {
+            type: "boolean",
+            description: "Skip functions named handle* or on* in .tsx/.jsx files. Default: true."
+          }
+        },
+        additionalProperties: false
+      }
+    ],
     messages: {
-      asyncWithoutAwait: "Async function does not contain `await`. AI tools frequently add `async` unnecessarily, which can mislead callers and mask intent. Remove `async` or add proper await logic."
+      asyncWithoutAwait: "Async function does not contain `await`. AI tools frequently add `async` unnecessarily, which can mislead callers and mask intent. Remove `async` or add proper await logic.",
+      asyncPassThrough: "Async pass-through wrapper \u2014 this may be intentional for Promise propagation. Consider whether `async` is needed here."
     }
   },
-  defaultOptions: [],
-  create(context) {
+  defaultOptions: [{}],
+  create(context, [options]) {
+    const {
+      allowedFunctionNames = [],
+      ignorePassThroughWrappers = true,
+      ignoreHandlerFunctions = true
+    } = options;
+    const skipNames = /* @__PURE__ */ new Set([...HTTP_METHOD_EXPORTS, ...allowedFunctionNames]);
+    const filename = context.filename ?? context.getFilename?.() ?? "";
+    const fileExt = import_path2.default.extname(filename).toLowerCase();
+    const isFrameworkFile = FRAMEWORK_FILE_PATTERNS.some((pattern) => pattern.test(filename));
+    const isReactFile = REACT_FILE_EXTENSIONS.has(fileExt);
     function buildSafeAutofix2(node) {
       const sourceCode = context.sourceCode;
       if (node.body.type !== import_utils8.AST_NODE_TYPES.BlockStatement) {
@@ -1170,25 +1331,51 @@ var noAsyncWithoutAwait = createRule8({
       if (!node.async) {
         return;
       }
+      if (isFrameworkFile) {
+        return;
+      }
+      if (isFunctionExportedWithHttpMethodName(node)) {
+        return;
+      }
+      const funcName = getFunctionName(node);
+      if (funcName && skipNames.has(funcName)) {
+        return;
+      }
+      if (funcName && MIDDLEWARE_NAME_REGEX.test(funcName)) {
+        return;
+      }
+      if (ignoreHandlerFunctions && isReactFile && funcName && HANDLER_NAME_REGEX.test(funcName)) {
+        return;
+      }
+      const bodyHasAwait = node.body.type === import_utils8.AST_NODE_TYPES.BlockStatement ? containsAwaitExpression(node.body) : node.body.type === import_utils8.AST_NODE_TYPES.AwaitExpression;
+      if (bodyHasAwait) {
+        return;
+      }
+      if (ignorePassThroughWrappers && isPassThroughWrapper(node)) {
+        context.report({
+          node,
+          messageId: "asyncPassThrough"
+          // No autofix for pass-through — it's intentional
+        });
+        return;
+      }
       if (node.body.type !== import_utils8.AST_NODE_TYPES.BlockStatement) {
         if (node.body.type !== import_utils8.AST_NODE_TYPES.AwaitExpression) {
-          const fix = buildSafeAutofix2(node);
+          const fix2 = buildSafeAutofix2(node);
           context.report({
             node,
             messageId: "asyncWithoutAwait",
-            fix
+            fix: fix2
           });
         }
         return;
       }
-      if (!containsAwaitExpression(node.body)) {
-        const fix = buildSafeAutofix2(node);
-        context.report({
-          node,
-          messageId: "asyncWithoutAwait",
-          fix
-        });
-      }
+      const fix = buildSafeAutofix2(node);
+      context.report({
+        node,
+        messageId: "asyncWithoutAwait",
+        fix
+      });
     }
     return {
       FunctionDeclaration: reportIfNeeded,
@@ -1464,10 +1651,20 @@ var noEvalDynamic = createRule11({
             messageId: "evalDynamic",
             data: { callee: `${node.callee.object.name}.eval()` }
           });
+          return;
+        }
+        if (isFunctionConstructorCallee(node.callee)) {
+          if (node.arguments.length === 0) return;
+          const allLiteral = node.arguments.every(isLiteral);
+          if (allLiteral) return;
+          context.report({
+            node,
+            messageId: "newFunctionDynamic"
+          });
         }
       },
       NewExpression(node) {
-        if (node.callee.type === import_utils11.AST_NODE_TYPES.Identifier && node.callee.name === "Function") {
+        if (isFunctionConstructorCallee(node.callee)) {
           if (node.arguments.length === 0) return;
           const allLiteral = node.arguments.every(isLiteral);
           if (allLiteral) return;
@@ -1480,6 +1677,15 @@ var noEvalDynamic = createRule11({
     };
   }
 });
+function isFunctionConstructorCallee(callee) {
+  if (callee.type === import_utils11.AST_NODE_TYPES.Identifier && callee.name === "Function") {
+    return true;
+  }
+  if (callee.type === import_utils11.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils11.AST_NODE_TYPES.Identifier && callee.property.name === "Function" && callee.object.type === import_utils11.AST_NODE_TYPES.Identifier && (callee.object.name === "window" || callee.object.name === "globalThis")) {
+    return true;
+  }
+  return false;
+}
 function isLiteral(node) {
   if (node.type === import_utils11.AST_NODE_TYPES.Literal) return true;
   if (node.type === import_utils11.AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0) {
@@ -1897,6 +2103,8 @@ var PUBLIC_ROUTE_PATTERNS = [
   // reset password
   /^\/webhook/,
   // webhooks
+  /^\/callback/,
+  // OAuth callback
   /^\/public/,
   // explicitly public
   /^\/assets/,
@@ -1907,8 +2115,12 @@ var PUBLIC_ROUTE_PATTERNS = [
   // favicon
   /^\/robots/,
   // robots.txt
-  /^\/sitemap/
+  /^\/sitemap/,
   // sitemap
+  /^\/api\/docs/,
+  // API documentation (Swagger, etc.)
+  /^\/docs/
+  // documentation
 ];
 var requireAuthMiddleware = createRule14({
   name: "require-auth-middleware",
@@ -2005,6 +2217,13 @@ function isAuthMiddleware(node, authNames) {
   if (node.type === import_utils14.AST_NODE_TYPES.Identifier) {
     return authNames.has(node.name);
   }
+  if (node.type === import_utils14.AST_NODE_TYPES.ObjectExpression) {
+    for (const prop of node.properties) {
+      if (prop.type === import_utils14.AST_NODE_TYPES.Property && prop.key.type === import_utils14.AST_NODE_TYPES.Identifier && (prop.key.name === "preHandler" || prop.key.name === "onRequest")) {
+        if (isAuthMiddleware(prop.value, authNames)) return true;
+      }
+    }
+  }
   if (node.type === import_utils14.AST_NODE_TYPES.CallExpression) {
     if (node.callee.type === import_utils14.AST_NODE_TYPES.Identifier) {
       return authNames.has(node.callee.name);
@@ -2090,29 +2309,29 @@ function getMemberPath(node) {
   }
   return [...objectPath, node.property.name];
 }
-function hasPathPrefix(path, prefix) {
-  if (!path || path.length < prefix.length) {
+function hasPathPrefix(path3, prefix) {
+  if (!path3 || path3.length < prefix.length) {
     return false;
   }
   for (let i = 0; i < prefix.length; i += 1) {
-    if (path[i] !== prefix[i]) {
+    if (path3[i] !== prefix[i]) {
       return false;
     }
   }
   return true;
 }
-function isLikelyResourceIdPath(path) {
-  if (!path || path.length < 3) {
+function isLikelyResourceIdPath(path3) {
+  if (!path3 || path3.length < 3) {
     return false;
   }
-  if (!hasPathPrefix(path, ["req", "params"]) && !hasPathPrefix(path, ["req", "body"]) && !hasPathPrefix(path, ["req", "query"])) {
+  if (!hasPathPrefix(path3, ["req", "params"]) && !hasPathPrefix(path3, ["req", "body"]) && !hasPathPrefix(path3, ["req", "query"])) {
     return false;
   }
-  const last = path[path.length - 1].toLowerCase();
+  const last = path3[path3.length - 1].toLowerCase();
   return last === "id" || last.endsWith("id");
 }
-function isReqUserPath(path) {
-  return hasPathPrefix(path, ["req", "user"]);
+function isReqUserPath(path3) {
+  return hasPathPrefix(path3, ["req", "user"]);
 }
 function containsAuthorizationHelper(node) {
   if (node.type === import_utils15.AST_NODE_TYPES.CallExpression && (node.callee.type === import_utils15.AST_NODE_TYPES.Identifier && AUTHZ_HELPER_NAMES.includes(node.callee.name) || node.callee.type === import_utils15.AST_NODE_TYPES.MemberExpression && node.callee.property.type === import_utils15.AST_NODE_TYPES.Identifier && AUTHZ_HELPER_NAMES.includes(node.callee.property.name))) {
@@ -2151,8 +2370,8 @@ function collectBodySignals(node) {
       }
     }
     if (current.type === import_utils15.AST_NODE_TYPES.MemberExpression) {
-      const path = getMemberPath(current);
-      if (isLikelyResourceIdPath(path)) {
+      const path3 = getMemberPath(current);
+      if (isLikelyResourceIdPath(path3)) {
         hasResourceIdAccess = true;
       }
     }
@@ -2221,7 +2440,7 @@ var requireAuthzCheck = createRule15({
   }
 });
 
-// src/rules/quality/no-console-in-handler.ts
+// src/rules/ai-patterns/no-console-in-handler.ts
 var import_utils16 = require("@typescript-eslint/utils");
 var createRule16 = import_utils16.ESLintUtils.RuleCreator(
   (name) => `https://github.com/YashJadhav21/eslint-plugin-ai-guard/blob/main/docs/rules/${name}.md`
@@ -2331,7 +2550,7 @@ var noConsoleInHandler = createRule16({
   }
 });
 
-// src/rules/logic/no-duplicate-logic-block.ts
+// src/rules/ai-patterns/no-duplicate-logic-block.ts
 var import_utils17 = require("@typescript-eslint/utils");
 var createRule17 = import_utils17.ESLintUtils.RuleCreator(
   (name) => `https://github.com/YashJadhav21/eslint-plugin-ai-guard/blob/main/docs/rules/${name}.md`
@@ -2396,25 +2615,127 @@ var noDuplicateLogicBlock = createRule17({
   }
 });
 
+// src/rules/ai-patterns/no-dead-branch.ts
+var import_utils18 = require("@typescript-eslint/utils");
+var createRule18 = import_utils18.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/YashJadhav21/eslint-plugin-ai-guard/blob/main/docs/rules/${name}.md`
+);
+function isBooleanLiteral(node, value) {
+  return node.type === import_utils18.AST_NODE_TYPES.Literal && typeof node.value === "boolean" && node.value === value;
+}
+function isZeroLiteral(node) {
+  return node.type === import_utils18.AST_NODE_TYPES.Literal && typeof node.value === "number" && node.value === 0;
+}
+function isEmptyStringLiteral(node) {
+  return node.type === import_utils18.AST_NODE_TYPES.Literal && typeof node.value === "string" && node.value === "";
+}
+function isAlwaysTrue(node) {
+  if (isBooleanLiteral(node, true)) return true;
+  if (node.type === import_utils18.AST_NODE_TYPES.LogicalExpression && node.operator === "||") {
+    const { left, right } = node;
+    if (left.type === import_utils18.AST_NODE_TYPES.Identifier && right.type === import_utils18.AST_NODE_TYPES.UnaryExpression && right.operator === "!" && right.argument.type === import_utils18.AST_NODE_TYPES.Identifier && left.name === right.argument.name) {
+      return true;
+    }
+  }
+  if (node.type === import_utils18.AST_NODE_TYPES.BinaryExpression && (node.operator === "===" || node.operator === "==") && node.left.type === import_utils18.AST_NODE_TYPES.Identifier && node.right.type === import_utils18.AST_NODE_TYPES.Identifier && node.left.name === node.right.name) {
+    return true;
+  }
+  return false;
+}
+function isAlwaysFalse(node) {
+  if (isBooleanLiteral(node, false)) return true;
+  if (isZeroLiteral(node)) return true;
+  if (isEmptyStringLiteral(node)) return true;
+  if (node.type === import_utils18.AST_NODE_TYPES.LogicalExpression && node.operator === "&&") {
+    const { left, right } = node;
+    if (left.type === import_utils18.AST_NODE_TYPES.Identifier && right.type === import_utils18.AST_NODE_TYPES.UnaryExpression && right.operator === "!" && right.argument.type === import_utils18.AST_NODE_TYPES.Identifier && left.name === right.argument.name) {
+      return true;
+    }
+  }
+  if (node.type === import_utils18.AST_NODE_TYPES.BinaryExpression && (node.operator === "!==" || node.operator === "!=") && node.left.type === import_utils18.AST_NODE_TYPES.Identifier && node.right.type === import_utils18.AST_NODE_TYPES.Identifier && node.left.name === node.right.name) {
+    return true;
+  }
+  return false;
+}
+var noDeadBranch = createRule18({
+  name: "no-dead-branch",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow conditions that are statically always-true or always-false. AI tools frequently generate dead branches like `if (true)`, `if (false)`, `if (x && !x)`, or `x === x` \u2014 leftover scaffolding that clutters the code and hides logical errors."
+    },
+    fixable: void 0,
+    schema: [],
+    messages: {
+      alwaysTrue: "This condition is always `true` \u2014 the branch is never skipped. AI tools often generate this as leftover scaffolding. Remove the condition or replace it with the intended logic.",
+      alwaysFalse: "This condition is always `false` \u2014 this branch is dead and never executed. AI tools often generate this as leftover scaffolding. Remove the dead branch entirely.",
+      whileFalse: "This `while (false)` loop never executes. AI tools sometimes generate this as a placeholder. Remove it or replace with the intended loop condition."
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    function checkCondition(testNode, reportNode, isBranchStatement) {
+      if (!testNode) return;
+      if (isAlwaysFalse(testNode)) {
+        context.report({
+          node: reportNode,
+          messageId: isBranchStatement ? "alwaysFalse" : "whileFalse"
+        });
+        return;
+      }
+      if (isAlwaysTrue(testNode)) {
+        if (reportNode.type === import_utils18.AST_NODE_TYPES.WhileStatement) return;
+        context.report({
+          node: reportNode,
+          messageId: "alwaysTrue"
+        });
+      }
+    }
+    return {
+      IfStatement(node) {
+        checkCondition(node.test, node, true);
+      },
+      WhileStatement(node) {
+        if (isAlwaysFalse(node.test)) {
+          context.report({ node, messageId: "whileFalse" });
+        }
+      },
+      DoWhileStatement(node) {
+        if (isAlwaysFalse(node.test)) {
+          context.report({ node, messageId: "whileFalse" });
+        }
+      },
+      ConditionalExpression(node) {
+        checkCondition(node.test, node, true);
+      }
+    };
+  }
+});
+
 // src/rules/index.ts
 var allRules = {
+  // Reliability
   "no-empty-catch": noEmptyCatch,
   "no-broad-exception": noBroadException,
   "no-catch-log-rethrow": noCatchLogRethrow,
   "no-catch-without-use": noCatchWithoutUse,
+  // Async
   "no-async-array-callback": noAsyncArrayCallback,
   "no-floating-promise": noFloatingPromise,
   "no-await-in-loop": noAwaitInLoop,
   "no-async-without-await": noAsyncWithoutAwait,
   "no-redundant-await": noRedundantAwait,
+  // Security
   "no-hardcoded-secret": noHardcodedSecret,
   "no-eval-dynamic": noEvalDynamic,
   "no-sql-string-concat": noSqlStringConcat,
   "no-unsafe-deserialize": noUnsafeDeserialize,
   "require-auth-middleware": requireAuthMiddleware,
   "require-authz-check": requireAuthzCheck,
+  // AI Patterns
   "no-console-in-handler": noConsoleInHandler,
-  "no-duplicate-logic-block": noDuplicateLogicBlock
+  "no-duplicate-logic-block": noDuplicateLogicBlock,
+  "no-dead-branch": noDeadBranch
 };
 
 // src/configs/recommended.ts
@@ -2424,27 +2745,35 @@ var recommended = {
     // Adoption-first default:
     // Keep only high-confidence, high-impact rules at error so first run is actionable,
     // not overwhelming. Context-sensitive rules are warn/off by design.
-    // Critical (error): low-noise, high-impact correctness/security failures.
+    // ── Reliability ────────────────────────────────────────────────────────────
+    // Critical (error): low-noise, high-impact correctness failures.
     "ai-guard/no-empty-catch": "error",
-    "ai-guard/no-floating-promise": "error",
-    "ai-guard/no-hardcoded-secret": "error",
-    "ai-guard/no-eval-dynamic": "error",
-    // Important but noisier/context-dependent (warn): useful guidance without blocking.
+    // Important but context-dependent (warn).
     "ai-guard/no-broad-exception": "warn",
-    "ai-guard/require-auth-middleware": "warn",
+    // Off in recommended — too noisy in mixed codebases.
+    "ai-guard/no-catch-without-use": "off",
+    "ai-guard/no-catch-log-rethrow": "off",
+    // ── Async ──────────────────────────────────────────────────────────────────
+    "ai-guard/no-floating-promise": "error",
     "ai-guard/no-await-in-loop": "warn",
     "ai-guard/no-async-without-await": "warn",
-    "ai-guard/no-sql-string-concat": "warn",
-    // Kept as warn in recommended to reduce false positives in mixed codebases.
     "ai-guard/no-async-array-callback": "warn",
-    // Optional/contextual (off): available for teams via strict/custom configs.
-    // Intentional for trust and gradual adoption.
-    "ai-guard/no-console-in-handler": "off",
+    // Off in recommended — reduces noise in common patterns.
     "ai-guard/no-redundant-await": "off",
-    "ai-guard/no-catch-without-use": "off",
+    // ── Security ───────────────────────────────────────────────────────────────
+    // Critical (error): direct security vulnerabilities.
+    "ai-guard/no-hardcoded-secret": "error",
+    "ai-guard/no-eval-dynamic": "error",
+    // Context-sensitive (warn): useful but require project context.
+    "ai-guard/no-sql-string-concat": "warn",
     "ai-guard/no-unsafe-deserialize": "warn",
-    "ai-guard/no-catch-log-rethrow": "off",
+    "ai-guard/require-auth-middleware": "warn",
     "ai-guard/require-authz-check": "warn",
+    // ── AI Patterns ────────────────────────────────────────────────────────────
+    // Warn: useful signal, but may fire in intentional dead-code removal flows.
+    "ai-guard/no-dead-branch": "warn",
+    // Off in recommended — contextual rules for teams opting into stricter checks.
+    "ai-guard/no-console-in-handler": "off",
     "ai-guard/no-duplicate-logic-block": "off"
   }
 };
@@ -2474,9 +2803,10 @@ var strict = {
     "ai-guard/no-unsafe-deserialize": "error",
     "ai-guard/require-auth-middleware": "error",
     "ai-guard/require-authz-check": "error",
-    // Quality - all at error
+    // AI Patterns - all at error
     "ai-guard/no-console-in-handler": "error",
-    "ai-guard/no-duplicate-logic-block": "error"
+    "ai-guard/no-duplicate-logic-block": "error",
+    "ai-guard/no-dead-branch": "error"
   }
 };
 var strict_default = strict;
@@ -2501,7 +2831,7 @@ var security_default = security;
 var plugin = {
   meta: {
     name: "eslint-plugin-ai-guard",
-    version: "1.1.13"
+    version: "1.2.0"
   },
   rules: allRules,
   configs: {