eslint-plugin-harlanzw 0.2.5 → 0.3.0

package/dist/index.d.mts

@@ -39,6 +39,11 @@ interface HarlanzwOptions {
 declare function harlanzw(options?: HarlanzwOptions, ...extraConfigs: Linter.Config[]): Linter.Config[];
 declare namespace harlanzw {
     var plugin;
+    var detectFramework: () => {
+        nuxt: boolean;
+        vue: boolean;
+        prompt: boolean;
+    };
 }
 
 type RuleDefinitions = typeof plugin['rules'];

package/dist/index.mjs

@@ -1,7 +1,9 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
 import { TextSourceCodeBase, ConfigCommentParser, Directive, VisitNodeStep } from '@eslint/plugin-kit';
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
-const version = "0.2.5";
+const version = "0.3.0";
 
 const STRENGTH_PATTERNS = {
   strong: ["never", "must", "always", "under no circumstances", "absolutely", "required", "mandatory", "forbidden", "prohibited"],
@@ -70,18 +72,32 @@ const COMMON_CONTEXT_VARIABLES = /* @__PURE__ */ new Set([
   "branch"
 ]);
 const PROMPT_FILES = [
+  // Claude Code — root + nested CLAUDE.md are auto-loaded
   "**/CLAUDE.md",
-  "**/.claude/**/*.md",
-  "**/AGENTS.md",
+  // Claude Code — skills
+  "**/SKILL.md",
+  // Claude Code — commands (loaded on invoke)
+  "**/.claude/commands/**/*.md",
+  // Gemini
+  "**/.gemini/style_guide.md",
+  "**/GEMINI.md",
+  // GitHub Copilot
   "**/.github/copilot-instructions.md",
+  // Cursor
   "**/.cursorrules",
   "**/.cursor/rules/**/*.md",
   "**/.cursor/rules/**/*.mdc",
-  "**/SKILL.md",
+  // Windsurf
   "**/.windsurfrules",
+  // Cline
   "**/.clinerules",
+  // Goose
   "**/.goose/instructions.md",
+  // Amp
   "**/.amp/RULES.md",
+  // Codex
+  "**/AGENTS.md",
+  // Generic prompt files
   "**/*.prompt",
   "**/*.prompt.md"
 ];
@@ -2149,7 +2165,10 @@ const BAD_LINK_TEXTS = /* @__PURE__ */ new Set([
   "discover"
 ]);
 function getVueElementText(node) {
-  return (node.children || []).filter((child) => child.type === "VText").map((child) => child.value).join("").trim();
+  const children = node.children || [];
+  if (children.some((child) => child.type === "VElement" || child.type === "VExpressionContainer"))
+    return "[dynamic]";
+  return children.filter((child) => child.type === "VText").map((child) => child.value).join("").trim() || null;
 }
 function getVueAttrValue(node, name) {
   if (!node.startTag?.attributes)
@@ -2157,6 +2176,8 @@ function getVueAttrValue(node, name) {
   for (const attr of node.startTag.attributes) {
     if (attr.key?.name === name && attr.value?.type === "VLiteral")
       return attr.value.value;
+    if (attr.directive && attr.key?.name?.name === "bind" && attr.key?.argument?.name === name)
+      return "[dynamic]";
   }
   return null;
 }
@@ -3021,6 +3042,8 @@ const vueNoFauxComposables = createEslintRule({
           return expr.properties.some((prop) => prop.type === "Property" && hasReactivityInExpression(prop.value));
         case "ArrayExpression":
           return expr.elements.some((elem) => hasReactivityInExpression(elem));
+        case "AwaitExpression":
+          return hasReactivityInExpression(expr.argument);
         default:
           return false;
       }
@@ -3092,12 +3115,15 @@ const vueNoNestedReactivity = createEslintRule({
       noNestedInShallowReactive: "Avoid nesting reactivity primitives inside shallowReactive().",
       noNestedInComputed: "Avoid nesting reactivity primitives inside computed().",
       noNestedInWatch: "Avoid nesting reactivity primitives inside watch().",
-      noNestedInWatchEffect: "Avoid nesting reactivity primitives inside watchEffect()."
+      noNestedInWatchEffect: "Avoid nesting reactivity primitives inside watchEffect().",
+      reactiveInWatchCallback: "Avoid creating reactive primitives inside watch() callbacks. They will be recreated on every trigger.",
+      reactiveInWatchEffectCallback: "Avoid creating reactive primitives inside watchEffect() callbacks. They will be recreated on every run."
     }
   },
   defaultOptions: [],
   create: (context) => {
     const reactiveAPIs = /* @__PURE__ */ new Set(["ref", "reactive", "shallowRef", "shallowReactive", "computed", "watch", "watchEffect"]);
+    const stateCreatingAPIs = /* @__PURE__ */ new Set(["ref", "reactive", "shallowRef", "shallowReactive", "computed"]);
     const vueImports = /* @__PURE__ */ new Set();
     const nonVueImports = /* @__PURE__ */ new Set();
     const reactiveVariables = /* @__PURE__ */ new Map();
@@ -3225,6 +3251,8 @@ const vueNoNestedReactivity = createEslintRule({
     function checkForNestedReactivity(node, outerType) {
       if (!node.arguments.length)
         return;
+      if (outerType === "watch" || outerType === "watchEffect")
+        return;
       const arg = node.arguments[0];
       if (arg.type === "ObjectExpression") {
         checkObjectExpressionForReactivity(arg, outerType);
@@ -3238,6 +3266,34 @@ const vueNoNestedReactivity = createEslintRule({
         }
       }
     }
+    function getEnclosingWatchType(node) {
+      let current = node.parent;
+      while (current) {
+        if ((current.type === "ArrowFunctionExpression" || current.type === "FunctionExpression") && current.parent?.type === "CallExpression" && current.parent.callee.type === "Identifier") {
+          const callee = current.parent.callee.name;
+          const isVueWatch = vueImports.has(callee) || VUE_REACTIVITY_APIS.has(callee) && !nonVueImports.has(callee);
+          if (isVueWatch) {
+            if (callee === "watchEffect" && current.parent.arguments[0] === current)
+              return "watchEffect";
+            if (callee === "watch" && current.parent.arguments[1] === current)
+              return "watch";
+          }
+        }
+        current = current.parent;
+      }
+      return null;
+    }
+    function checkReactiveInWatchCallback(node, reactiveType) {
+      if (!stateCreatingAPIs.has(reactiveType))
+        return;
+      const watchType = getEnclosingWatchType(node);
+      if (watchType) {
+        context.report({
+          node,
+          messageId: watchType === "watch" ? "reactiveInWatchCallback" : "reactiveInWatchEffectCallback"
+        });
+      }
+    }
     const scriptVisitor = {
       Program() {
         vueImports.clear();
@@ -3258,6 +3314,7 @@ const vueNoNestedReactivity = createEslintRule({
         const reactiveType = isReactiveCall(node);
         if (reactiveType) {
           checkForNestedReactivity(node, reactiveType);
+          checkReactiveInWatchCallback(node, reactiveType);
         }
         checkComputedCallback(node);
       },
@@ -3276,6 +3333,7 @@ const vueNoNestedReactivity = createEslintRule({
         const reactiveType = isReactiveCall(node);
         if (reactiveType) {
           checkForNestedReactivity(node, reactiveType);
+          checkReactiveInWatchCallback(node, reactiveType);
         }
         checkComputedCallback(node);
       }
@@ -3746,6 +3804,19 @@ plugin.configs.recommended = [
   ...plugin.configs.nuxt,
   ...plugin.configs.vue
 ];
+const PROMPT_MARKERS = [
+  ".claude",
+  ".cursor",
+  ".github/copilot-instructions.md",
+  ".windsurfrules",
+  ".clinerules",
+  ".goose",
+  ".amp",
+  "CLAUDE.md",
+  "AGENTS.md",
+  ".cursorrules",
+  ".gemini"
+];
 function buildLinkRules(linkOpts) {
   const { requireTrailingSlash, ...baseOpts } = linkOpts;
   const rules = {
@@ -3759,8 +3830,9 @@ function buildLinkRules(linkOpts) {
   return rules;
 }
 function harlanzw(options = {}, ...extraConfigs) {
+  const detected = detectFramework();
   const configs = [];
-  if (options.link !== false && options.link !== void 0) {
+  if (options.link !== false) {
     const linkOpts = typeof options.link === "object" ? options.link : {};
     configs.push({
       name: "harlanzw/link",
@@ -3769,19 +3841,38 @@ function harlanzw(options = {}, ...extraConfigs) {
       rules: buildLinkRules(linkOpts)
     });
   }
-  if (options.prompt !== false) {
+  const enablePrompt = options.prompt ?? detected.prompt;
+  if (enablePrompt) {
     const preset = typeof options.prompt === "string" ? options.prompt : "recommended";
     configs.push(...plugin.configs[`prompt:${preset}`]);
   }
-  if (options.nuxt) {
+  const enableNuxt = options.nuxt ?? detected.nuxt;
+  if (enableNuxt) {
     configs.push(...plugin.configs.nuxt);
   }
-  if (options.vue) {
+  const enableVue = options.vue ?? detected.vue;
+  if (enableVue) {
     configs.push(...plugin.configs.vue);
   }
   configs.push(...extraConfigs);
   return configs;
 }
+function detectFramework() {
+  const cwd = process.cwd();
+  const nuxt = existsSync(resolve(cwd, "nuxt.config.ts")) || existsSync(resolve(cwd, "nuxt.config.js"));
+  let vue = nuxt;
+  if (!vue) {
+    try {
+      const pkg = JSON.parse(readFileSync(resolve(cwd, "package.json"), "utf-8"));
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      vue = !!(deps.vue || deps.nuxt);
+    } catch {
+    }
+  }
+  const prompt = PROMPT_MARKERS.some((m) => existsSync(resolve(cwd, m)));
+  return { nuxt, vue, prompt };
+}
 harlanzw.plugin = plugin;
+harlanzw.detectFramework = detectFramework;
 
 export { harlanzw as default, plugin };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eslint-plugin-harlanzw",
   "type": "module",
-  "version": "0.2.5",
+  "version": "0.3.0",
   "description": "Harlan's opinionated ESLint rules",
   "author": "Harlan Wilton <harlan@harlanzw.com>",
   "license": "MIT",