eslint-config-agent 1.0.21 → 1.0.23

package/CHANGELOG.md

@@ -4,6 +4,22 @@ All notable changes to this project will be documented in this file. See [Conven
 
 
 
+## [1.0.23](https://github.com/tupe12334/eslint-config/compare/v1.0.22...v1.0.23) (2025-09-05)
+
+### Features
+
+* add custom no-env-access rule with tests and update test runner ([b4f4fc5](https://github.com/tupe12334/eslint-config/commit/b4f4fc5fdecfdc8fa6f1524403d2f6df8afb3a40))
+
+## [1.0.22](https://github.com/tupe12334/eslint-config/compare/v1.0.21...v1.0.22) (2025-09-04)
+
+### Features
+
+* add max-lines and max-lines-per-function rules with configurations and tests ([218f29c](https://github.com/tupe12334/eslint-config/commit/218f29ca497ca1b49e027f3e33f87cf836e7ff02))
+
+### Bug Fixes
+
+* resolve linting issues for release ([3c812cd](https://github.com/tupe12334/eslint-config/commit/3c812cd223f169360cb0d1520e401a17a6a9b960))
+
 ## [1.0.21](https://github.com/tupe12334/eslint-config/compare/v1.0.19...v1.0.21) (2025-09-04)
 
 ### Bug Fixes

package/index.js

@@ -1,4 +1,3 @@
-import { FlatCompat } from "@eslint/eslintrc";
 import js from "@eslint/js";
 import tsPlugin from "@typescript-eslint/eslint-plugin";
 import tsParser from "@typescript-eslint/parser";
@@ -7,6 +6,9 @@ import reactPlugin from "eslint-plugin-react";
 import importPlugin from "eslint-plugin-import";
 import globals from "globals";
 import noTrailingSpacesConfig from "./rules/no-trailing-spaces/index.js";
+import { maxFunctionLinesWarning, maxFunctionLinesError } from "./rules/max-function-lines/index.js";
+import { maxFileLinesWarning, maxFileLinesError } from "./rules/max-file-lines/index.js";
+import noEnvAccessRule from "./rules/no-env-access/index.js";
 
 // Conditionally import preact plugin if available
 let preactPlugin = null;
@@ -16,9 +18,6 @@ try {
   // eslint-plugin-preact is not available
 }
 
-const compat = new FlatCompat({
-  recommendedConfig: js.configs.recommended,
-});
 
 // Shared rules for both JS and TS files
 const sharedRules = {
@@ -41,10 +40,8 @@ const sharedRules = {
   "import/first": "off",
   "import/prefer-default-export": "off",
   "react/react-in-jsx-scope": "off",
-  "max-lines-per-function": [
-    "warn",
-    { max: 100, skipBlankLines: true, skipComments: true },
-  ],
+  "max-lines-per-function": maxFunctionLinesWarning,
+  "max-lines": maxFileLinesWarning,
   "react/jsx-filename-extension": ["error", { extensions: [".tsx", ".jsx"] }],
   semi: "off",
   "react/function-component-definition": "off",
@@ -64,6 +61,7 @@ const sharedRules = {
   "react/jsx-no-useless-fragment": "off",
   "import/group-exports": "off",
   "import/no-default-export": "off",
+  "custom-rules/no-env-access": "error",
 };
 
 // Shared no-restricted-syntax rules for both JS and TS
@@ -73,8 +71,10 @@ const sharedRestrictedSyntax = [
     message: "Optional chaining is not allowed.",
   },
   {
-    selector: "MemberExpression[object.type='MemberExpression'][object.object.name='process'][object.property.name='env']",
-    message: "Direct access to process.env properties is not allowed. Use a configuration object or environment validation instead.",
+    selector:
+      "MemberExpression[object.type='MemberExpression'][object.object.name='process'][object.property.name='env']",
+    message:
+      "Direct access to process.env properties is not allowed. Use a configuration object or environment validation instead.",
   },
   {
     selector: "CallExpression[optional=true]",
@@ -255,13 +255,22 @@ const tsOnlyRestrictedSyntax = [
 ];
 
 const config = [
+  // Global plugin definitions
+  {
+    plugins: {
+      "custom-rules": {
+        rules: {
+          "no-env-access": noEnvAccessRule,
+        }
+      },
+    },
+  },
   reactHooks.configs["recommended-latest"],
   {
     ignores: ["packages/auth-service-sdk/**"],
   },
   js.configs.recommended,
 
-
   // TypeScript and TSX files
   {
     files: ["**/*.ts", "**/*.tsx"],
@@ -500,10 +509,7 @@ const config = [
     },
     rules: {
       ...sharedRules,
-      "no-restricted-syntax": [
-        "error",
-        ...sharedRestrictedSyntax,
-      ],
+      "no-restricted-syntax": ["error", ...sharedRestrictedSyntax],
     },
   },
 
@@ -769,8 +775,10 @@ const config = [
         "error",
         // Process.env rule (applies to all file types)
         {
-          selector: "MemberExpression[object.type='MemberExpression'][object.object.name='process'][object.property.name='env']",
-          message: "Direct access to process.env properties is not allowed. Use a configuration object or environment validation instead.",
+          selector:
+            "MemberExpression[object.type='MemberExpression'][object.object.name='process'][object.property.name='env']",
+          message:
+            "Direct access to process.env properties is not allowed. Use a configuration object or environment validation instead.",
         },
         // Switch case rules as errors
         {
@@ -853,6 +861,30 @@ const config = [
     },
   },
 
+  // Function and file length rules - strict error thresholds
+  {
+    files: ["**/*.{ts,tsx,js,jsx}"],
+    rules: {
+      // Function length: error at 70+ lines
+      "max-lines-per-function": maxFunctionLinesError,
+      // File length: error at 100+ lines
+      "max-lines": maxFileLinesError,
+    },
+  },
+
+  // Disable file length rules for configuration and spec files
+  {
+    files: [
+      "index.js", // Main configuration file
+      "**/rules/**/*.spec.js", // Spec files in rules directory
+      "**/scripts/**/*.js", // Script files
+    ],
+    rules: {
+      "max-lines": "off",
+      "max-lines-per-function": "off",
+    },
+  },
+
   // Allow default exports in configuration files (must be last to override)
   {
     files: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-config-agent",
-  "version": "1.0.21",
+  "version": "1.0.23",
   "description": "ESLint configuration package with TypeScript support",
   "main": "index.js",
   "type": "module",
@@ -29,7 +29,6 @@
     "test:performance": "eslint test/performance-test.tsx",
     "test:comprehensive": "node scripts/test-runner.js",
     "test:ci": "eslint . --ignore-pattern 'test/**' --ignore-pattern 'scripts/**' --max-warnings 0",
-    "test:rules": "node rules/no-trailing-spaces/no-trailing-spaces.spec.js",
     "validate": "node scripts/validate-config.js",
     "release": "dotenv -e .env -- release-it",
     "release:patch": "dotenv -e .env -- release-it patch",

package/rules/max-file-lines/index.js

@@ -0,0 +1,43 @@
+/**
+ * Rule configuration for max-lines
+ *
+ * This rule enforces a maximum number of lines per file to encourage
+ * smaller, more maintainable files and better separation of concerns.
+ *
+ * Warnings at >70 lines, errors at >100 lines
+ *
+ * @see https://eslint.org/docs/latest/rules/max-lines
+ */
+
+// Warning configuration (70 lines)
+export const warningRule = "warn";
+export const warningOptions = {
+  max: 70,
+  skipBlankLines: true,
+  skipComments: true,
+};
+
+// Error configuration (100 lines)
+export const errorRule = "error";
+export const errorOptions = {
+  max: 100,
+  skipBlankLines: true,
+  skipComments: true,
+};
+
+/**
+ * Export the warning rule configuration (applied first)
+ * Can be used in ESLint config as:
+ * "max-lines": maxFileLinesWarning
+ */
+export const maxFileLinesWarning = [warningRule, warningOptions];
+
+/**
+ * Export the error rule configuration (applied later to override)
+ * Can be used in ESLint config as:
+ * "max-lines": maxFileLinesError
+ */
+export const maxFileLinesError = [errorRule, errorOptions];
+
+// Default export is the warning configuration
+export default maxFileLinesWarning;

package/rules/max-file-lines/max-file-lines.spec.js

@@ -0,0 +1,75 @@
+/* global process */
+import {
+  warningRule,
+  warningOptions,
+  errorRule,
+  errorOptions,
+  maxFileLinesWarning,
+  maxFileLinesError
+} from "./index.js";
+
+console.log("Testing max-file-lines rule configuration exports...");
+
+// Test warning configuration
+console.log("\n📋 Warning Configuration:");
+console.log("Rule level:", warningRule);
+console.log("Options:", warningOptions);
+console.log("Complete config:", maxFileLinesWarning);
+
+// Validate warning configuration
+if (warningRule === "warn" &&
+    warningOptions.max === 70 &&
+    warningOptions.skipBlankLines === true &&
+    warningOptions.skipComments === true) {
+  console.log("✅ Warning configuration is correct");
+} else {
+  console.log("❌ Warning configuration is incorrect");
+  process.exit(1);
+}
+
+// Test error configuration
+console.log("\n📋 Error Configuration:");
+console.log("Rule level:", errorRule);
+console.log("Options:", errorOptions);
+console.log("Complete config:", maxFileLinesError);
+
+// Validate error configuration
+if (errorRule === "error" &&
+    errorOptions.max === 100 &&
+    errorOptions.skipBlankLines === true &&
+    errorOptions.skipComments === true) {
+  console.log("✅ Error configuration is correct");
+} else {
+  console.log("❌ Error configuration is incorrect");
+  process.exit(1);
+}
+
+console.log("\n✅ All max-file-lines configuration tests passed!");
+
+// Test that the configurations are properly formatted for ESLint
+console.log("\n📋 ESLint Configuration Format:");
+console.log("Warning format:", JSON.stringify(maxFileLinesWarning));
+console.log("Error format:", JSON.stringify(maxFileLinesError));
+
+// Validate ESLint format
+if (Array.isArray(maxFileLinesWarning) &&
+    maxFileLinesWarning.length === 2 &&
+    maxFileLinesWarning[0] === "warn" &&
+    typeof maxFileLinesWarning[1] === "object") {
+  console.log("✅ Warning ESLint format is correct");
+} else {
+  console.log("❌ Warning ESLint format is incorrect");
+  process.exit(1);
+}
+
+if (Array.isArray(maxFileLinesError) &&
+    maxFileLinesError.length === 2 &&
+    maxFileLinesError[0] === "error" &&
+    typeof maxFileLinesError[1] === "object") {
+  console.log("✅ Error ESLint format is correct");
+} else {
+  console.log("❌ Error ESLint format is incorrect");
+  process.exit(1);
+}
+
+console.log("\n🎉 All tests completed successfully!");

package/rules/max-function-lines/index.js

@@ -0,0 +1,43 @@
+/**
+ * Rule configuration for max-lines-per-function
+ *
+ * This rule enforces a maximum number of lines per function to encourage
+ * smaller, more maintainable functions.
+ *
+ * Warnings at >50 lines, errors at >70 lines
+ *
+ * @see https://eslint.org/docs/latest/rules/max-lines-per-function
+ */
+
+// Warning configuration (50 lines)
+export const warningRule = "warn";
+export const warningOptions = {
+  max: 50,
+  skipBlankLines: true,
+  skipComments: true,
+};
+
+// Error configuration (70 lines)
+export const errorRule = "error";
+export const errorOptions = {
+  max: 70,
+  skipBlankLines: true,
+  skipComments: true,
+};
+
+/**
+ * Export the warning rule configuration (applied first)
+ * Can be used in ESLint config as:
+ * "max-lines-per-function": maxFunctionLinesWarning
+ */
+export const maxFunctionLinesWarning = [warningRule, warningOptions];
+
+/**
+ * Export the error rule configuration (applied later to override)
+ * Can be used in ESLint config as:
+ * "max-lines-per-function": maxFunctionLinesError
+ */
+export const maxFunctionLinesError = [errorRule, errorOptions];
+
+// Default export is the warning configuration
+export default maxFunctionLinesWarning;

package/rules/max-function-lines/max-function-lines.spec.js

@@ -0,0 +1,75 @@
+/* global process */
+import {
+  warningRule,
+  warningOptions,
+  errorRule,
+  errorOptions,
+  maxFunctionLinesWarning,
+  maxFunctionLinesError
+} from "./index.js";
+
+console.log("Testing max-function-lines rule configuration exports...");
+
+// Test warning configuration
+console.log("\n📋 Warning Configuration:");
+console.log("Rule level:", warningRule);
+console.log("Options:", warningOptions);
+console.log("Complete config:", maxFunctionLinesWarning);
+
+// Validate warning configuration
+if (warningRule === "warn" &&
+    warningOptions.max === 50 &&
+    warningOptions.skipBlankLines === true &&
+    warningOptions.skipComments === true) {
+  console.log("✅ Warning configuration is correct");
+} else {
+  console.log("❌ Warning configuration is incorrect");
+  process.exit(1);
+}
+
+// Test error configuration
+console.log("\n📋 Error Configuration:");
+console.log("Rule level:", errorRule);
+console.log("Options:", errorOptions);
+console.log("Complete config:", maxFunctionLinesError);
+
+// Validate error configuration
+if (errorRule === "error" &&
+    errorOptions.max === 70 &&
+    errorOptions.skipBlankLines === true &&
+    errorOptions.skipComments === true) {
+  console.log("✅ Error configuration is correct");
+} else {
+  console.log("❌ Error configuration is incorrect");
+  process.exit(1);
+}
+
+console.log("\n✅ All max-function-lines configuration tests passed!");
+
+// Test that the configurations are properly formatted for ESLint
+console.log("\n📋 ESLint Configuration Format:");
+console.log("Warning format:", JSON.stringify(maxFunctionLinesWarning));
+console.log("Error format:", JSON.stringify(maxFunctionLinesError));
+
+// Validate ESLint format
+if (Array.isArray(maxFunctionLinesWarning) &&
+    maxFunctionLinesWarning.length === 2 &&
+    maxFunctionLinesWarning[0] === "warn" &&
+    typeof maxFunctionLinesWarning[1] === "object") {
+  console.log("✅ Warning ESLint format is correct");
+} else {
+  console.log("❌ Warning ESLint format is incorrect");
+  process.exit(1);
+}
+
+if (Array.isArray(maxFunctionLinesError) &&
+    maxFunctionLinesError.length === 2 &&
+    maxFunctionLinesError[0] === "error" &&
+    typeof maxFunctionLinesError[1] === "object") {
+  console.log("✅ Error ESLint format is correct");
+} else {
+  console.log("❌ Error ESLint format is incorrect");
+  process.exit(1);
+}
+
+console.log("\n🎉 All tests completed successfully!");

package/rules/no-env-access/index.js

@@ -0,0 +1,66 @@
+/**
+ * Custom ESLint rule: no-env-access
+ *
+ * Prevents direct access to properties on variables named 'env'.
+ * This encourages the use of configuration objects or environment validation
+ * instead of directly accessing environment variables.
+ *
+ * @example
+ * // ❌ Bad - direct env access
+ * const nodeEnv = env.NODE_ENV;
+ * const port = env.PORT;
+ *
+ * // ✅ Good - configuration object
+ * const config = getEnvConfig();
+ * const nodeEnv = config.nodeEnv;
+ *
+ * // ✅ Good - not property access
+ * const env = 'production';
+ * const envConfig = { env: 'development' };
+ */
+
+const rule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow direct access to properties on 'env' variables",
+      category: "Best Practices",
+      recommended: true,
+    },
+    messages: {
+      noEnvAccess:
+        "Direct access to env properties is not allowed. Use a configuration object or environment validation instead.",
+    },
+    schema: [], // No options
+  },
+
+  create(context) {
+    return {
+      MemberExpression(node) {
+        // Check if we're accessing a property on a variable named 'env'
+        if (
+          node.object &&
+          node.object.type === "Identifier" &&
+          node.object.name === "env" &&
+          node.computed === false // Only flag dot notation, not bracket notation
+        ) {
+          // Don't flag if this member expression itself is being called as a function
+          // e.g., env.call(), env.apply(), but do flag env.NODE_ENV.toLowerCase()
+          const isDirectMethodCall =
+            node.parent &&
+            node.parent.type === "CallExpression" &&
+            node.parent.callee === node;
+
+          if (!isDirectMethodCall) {
+            context.report({
+              node,
+              messageId: "noEnvAccess",
+            });
+          }
+        }
+      },
+    };
+  },
+};
+
+export default rule;

package/rules/no-env-access/no-env-access.spec.js

@@ -0,0 +1,196 @@
+import { RuleTester } from "eslint";
+import noEnvAccessRule from "./index.js";
+
+// Create RuleTester instance
+const ruleTester = new RuleTester({
+  languageOptions: {
+    ecmaVersion: "latest",
+    sourceType: "module",
+  },
+});
+
+// Test the no-env-access custom rule
+ruleTester.run("no-env-access", noEnvAccessRule, {
+  valid: [
+    // Valid: not accessing properties on 'env'
+    "const foo = 'bar';",
+    "const config = getEnvConfig();",
+    "const nodeEnv = config.NODE_ENV;",
+
+    // Valid: 'env' as a value, not property access
+    "const env = 'production';",
+    "const environment = env;",
+    "const settings = { env: 'development' };",
+    "const mode = settings.env;",
+
+    // Valid: different variable names
+    "const environment = { NODE_ENV: 'test' };",
+    "const nodeEnv = environment.NODE_ENV;",
+    "const config = { NODE_ENV: 'prod' };",
+    "const env_config = { PORT: 3000 };",
+    "const port = env_config.PORT;",
+
+    // Valid: function calls
+    "env();",
+    "env.call();",
+    "env.apply();",
+    "getEnv().NODE_ENV;",
+
+    // Valid: bracket notation (not enforced by this rule)
+    "const nodeEnv = env['NODE_ENV'];",
+    "const port = env['PORT'];",
+
+    // Valid: other operations
+    "typeof env;",
+    "env instanceof Object;",
+    "env || 'default';",
+    "env ? 'prod' : 'dev';",
+
+    // Valid: in function parameters, destructuring, etc.
+    "function test(env) { return env; }",
+    "const { env } = config;",
+    "const [env] = environments;",
+
+    // Valid: class members named env
+    "class Config { env = 'prod'; }",
+    "const config = new Config(); config.env;",
+
+    // Valid: accessing properties on process.env (handled by different rule)
+    "const nodeEnv = process.env.NODE_ENV;",
+    "const port = process.env.PORT;",
+  ],
+
+  invalid: [
+    // Invalid: direct property access on 'env' variable
+    {
+      code: "const nodeEnv = env.NODE_ENV;",
+      errors: [
+        {
+          messageId: "noEnvAccess",
+          type: "MemberExpression",
+        },
+      ],
+    },
+    {
+      code: "const port = env.PORT;",
+      errors: [
+        {
+          messageId: "noEnvAccess",
+          type: "MemberExpression",
+        },
+      ],
+    },
+    {
+      code: "const apiUrl = env.API_URL;",
+      errors: [
+        {
+          messageId: "noEnvAccess",
+          type: "MemberExpression",
+        },
+      ],
+    },
+    {
+      code: "const dbUrl = env.DATABASE_URL;",
+      errors: [
+        {
+          messageId: "noEnvAccess",
+          type: "MemberExpression",
+        },
+      ],
+    },
+
+    // Invalid: multiple accesses in same code
+    {
+      code: `
+        const nodeEnv = env.NODE_ENV;
+        const port = env.PORT;
+        const dbUrl = env.DATABASE_URL;
+      `,
+      errors: [
+        { messageId: "noEnvAccess", type: "MemberExpression" },
+        { messageId: "noEnvAccess", type: "MemberExpression" },
+        { messageId: "noEnvAccess", type: "MemberExpression" },
+      ],
+    },
+
+    // Invalid: in various contexts
+    {
+      code: "console.log(env.NODE_ENV);",
+      errors: [{ messageId: "noEnvAccess", type: "MemberExpression" }],
+    },
+    {
+      code: "if (env.NODE_ENV === 'production') { }",
+      errors: [{ messageId: "noEnvAccess", type: "MemberExpression" }],
+    },
+    {
+      code: "const config = { nodeEnv: env.NODE_ENV };",
+      errors: [{ messageId: "noEnvAccess", type: "MemberExpression" }],
+    },
+    {
+      code: "function test() { return env.NODE_ENV || 'development'; }",
+      errors: [{ messageId: "noEnvAccess", type: "MemberExpression" }],
+    },
+    {
+      code: "const port = parseInt(env.PORT, 10);",
+      errors: [{ messageId: "noEnvAccess", type: "MemberExpression" }],
+    },
+
+    // Invalid: function calls on accessed properties
+    {
+      code: "const lower = env.NODE_ENV.toLowerCase();",
+      errors: [{ messageId: "noEnvAccess", type: "MemberExpression" }],
+    },
+    {
+      code: "const trimmed = env.API_URL.trim();",
+      errors: [{ messageId: "noEnvAccess", type: "MemberExpression" }],
+    },
+
+    // Invalid: in function parameters and returns
+    {
+      code: "function getNodeEnv() { return env.NODE_ENV; }",
+      errors: [{ messageId: "noEnvAccess", type: "MemberExpression" }],
+    },
+    {
+      code: "const fn = () => env.NODE_ENV;",
+      errors: [{ messageId: "noEnvAccess", type: "MemberExpression" }],
+    },
+    {
+      code: "someFunction(env.NODE_ENV, env.PORT);",
+      errors: [
+        { messageId: "noEnvAccess", type: "MemberExpression" },
+        { messageId: "noEnvAccess", type: "MemberExpression" },
+      ],
+    },
+
+    // Invalid: in object/array literals
+    {
+      code: "const config = [env.NODE_ENV, env.PORT];",
+      errors: [
+        { messageId: "noEnvAccess", type: "MemberExpression" },
+        { messageId: "noEnvAccess", type: "MemberExpression" },
+      ],
+    },
+
+    // Invalid: in template literals
+    {
+      code: "const message = `Environment: ${env.NODE_ENV}`;",
+      errors: [{ messageId: "noEnvAccess", type: "MemberExpression" }],
+    },
+
+    // Invalid: in assignments and operations
+    {
+      code: "let nodeEnv; nodeEnv = env.NODE_ENV;",
+      errors: [{ messageId: "noEnvAccess", type: "MemberExpression" }],
+    },
+    {
+      code: "const isDev = env.NODE_ENV === 'development';",
+      errors: [{ messageId: "noEnvAccess", type: "MemberExpression" }],
+    },
+  ],
+});
+
+console.log("✅ All no-env-access rule tests passed!");
+console.log("   Rule prevents direct access to properties on 'env' variables");
+console.log(
+  "   Encourages use of configuration objects for better environment handling"
+);