@harness-engineering/eslint-plugin 0.2.1 → 0.2.3

package/README.md

@@ -89,6 +89,14 @@ Create `harness.config.json` in your project root:
 | `no-sync-io-in-async`         | Disallow synchronous I/O in async functions      | warn    |
 | `no-unbounded-array-chains`   | Disallow unbounded array method chains           | warn    |
 
+### Cross-Platform Rules
+
+| Rule                          | Description                                   | Default |
+| ----------------------------- | --------------------------------------------- | ------- |
+| `no-unix-shell-command`       | Disallow Unix-specific shell commands         | warn    |
+| `no-hardcoded-path-separator` | Disallow hardcoded path separators            | warn    |
+| `require-path-normalization`  | Require path normalization for cross-platform | warn    |
+
 ## Configs
 
 - **recommended**: Architecture rules as errors, others as warnings

package/dist/index.d.ts

@@ -34,6 +34,9 @@ declare const rules: {
     'require-boundary-schema': _typescript_eslint_utils_ts_eslint.RuleModule<"missingSchema", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
         name: string;
     };
+    'require-path-normalization': _typescript_eslint_utils_ts_eslint.RuleModule<"missingNormalization", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
+        name: string;
+    };
 };
 
 declare const plugin: {
@@ -75,6 +78,9 @@ declare const plugin: {
         'require-boundary-schema': _typescript_eslint_utils_ts_eslint.RuleModule<"missingSchema", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
             name: string;
         };
+        'require-path-normalization': _typescript_eslint_utils_ts_eslint.RuleModule<"missingNormalization", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
+            name: string;
+        };
     };
     configs: {
         recommended: {
@@ -89,6 +95,7 @@ declare const plugin: {
                 '@harness-engineering/enforce-doc-exports': string;
                 '@harness-engineering/no-unix-shell-command': string;
                 '@harness-engineering/no-hardcoded-path-separator': string;
+                '@harness-engineering/require-path-normalization': string;
             };
         };
         strict: {
@@ -103,6 +110,7 @@ declare const plugin: {
                 '@harness-engineering/enforce-doc-exports': string;
                 '@harness-engineering/no-unix-shell-command': string;
                 '@harness-engineering/no-hardcoded-path-separator': string;
+                '@harness-engineering/require-path-normalization': string;
             };
         };
     };
@@ -150,6 +158,9 @@ declare const configs: {
                     'require-boundary-schema': _typescript_eslint_utils_ts_eslint.RuleModule<"missingSchema", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
                         name: string;
                     };
+                    'require-path-normalization': _typescript_eslint_utils_ts_eslint.RuleModule<"missingNormalization", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
+                        name: string;
+                    };
                 };
                 configs: /*elided*/ any;
             };
@@ -162,6 +173,7 @@ declare const configs: {
             '@harness-engineering/enforce-doc-exports': string;
             '@harness-engineering/no-unix-shell-command': string;
             '@harness-engineering/no-hardcoded-path-separator': string;
+            '@harness-engineering/require-path-normalization': string;
         };
     };
     strict: {
@@ -205,6 +217,9 @@ declare const configs: {
                     'require-boundary-schema': _typescript_eslint_utils_ts_eslint.RuleModule<"missingSchema", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
                         name: string;
                     };
+                    'require-path-normalization': _typescript_eslint_utils_ts_eslint.RuleModule<"missingNormalization", [], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
+                        name: string;
+                    };
                 };
                 configs: /*elided*/ any;
             };
@@ -217,6 +232,7 @@ declare const configs: {
             '@harness-engineering/enforce-doc-exports': string;
             '@harness-engineering/no-unix-shell-command': string;
             '@harness-engineering/no-hardcoded-path-separator': string;
+            '@harness-engineering/require-path-normalization': string;
         };
     };
 };

package/dist/index.js

@@ -23,34 +23,41 @@ function hasJSDocComment(node, sourceCode) {
   }
   return foundJSDoc;
 }
+var SKIP_KEYS = /* @__PURE__ */ new Set(["parent", "loc", "range", "tokens", "comments"]);
+var ZOD_PARSE_METHODS = /* @__PURE__ */ new Set(["parse", "safeParse"]);
+function isZodParseCall(node) {
+  if (node.type !== AST_NODE_TYPES.CallExpression) return false;
+  const callee = node.callee;
+  if (callee.type !== AST_NODE_TYPES.MemberExpression) return false;
+  const prop = callee.property;
+  if (prop.type !== AST_NODE_TYPES.Identifier) return false;
+  return ZOD_PARSE_METHODS.has(prop.name);
+}
+function visitChildren(node, visitor) {
+  for (const key of Object.keys(node)) {
+    if (SKIP_KEYS.has(key)) continue;
+    const value = node[key];
+    if (!value || typeof value !== "object") continue;
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item && typeof item === "object" && "type" in item) {
+          visitor(item);
+        }
+      }
+    } else if ("type" in value) {
+      visitor(value);
+    }
+  }
+}
 function hasZodValidation(body) {
   let found = false;
-  const skipKeys = /* @__PURE__ */ new Set(["parent", "loc", "range", "tokens", "comments"]);
   function visit(node) {
     if (found) return;
-    if (node.type === AST_NODE_TYPES.CallExpression && node.callee.type === AST_NODE_TYPES.MemberExpression) {
-      const prop = node.callee.property;
-      const propType = prop.type;
-      if (propType === AST_NODE_TYPES.Identifier && (prop.name === "parse" || prop.name === "safeParse")) {
-        found = true;
-        return;
-      }
-    }
-    for (const key of Object.keys(node)) {
-      if (skipKeys.has(key)) continue;
-      const value = node[key];
-      if (value && typeof value === "object") {
-        if (Array.isArray(value)) {
-          for (const item of value) {
-            if (item && typeof item === "object" && "type" in item) {
-              visit(item);
-            }
-          }
-        } else if ("type" in value) {
-          visit(value);
-        }
-      }
+    if (isZodParseCall(node)) {
+      found = true;
+      return;
     }
+    visitChildren(node, visit);
   }
   visit(body);
   return found;
@@ -106,30 +113,34 @@ var enforce_doc_exports_default = createRule({
         });
       }
     }
+    function getExportInfo(decl) {
+      const declType = decl.type;
+      if (declType === AST_NODE_TYPES2.FunctionDeclaration) {
+        const fn = decl;
+        return fn.id ? [{ kind: "function", name: fn.id.name }] : [];
+      }
+      if (declType === AST_NODE_TYPES2.ClassDeclaration) {
+        const cls = decl;
+        return cls.id ? [{ kind: "class", name: cls.id.name }] : [];
+      }
+      if (declType === AST_NODE_TYPES2.VariableDeclaration) {
+        const varDecl = decl;
+        return varDecl.declarations.filter((d) => d.id.type === AST_NODE_TYPES2.Identifier).map((d) => ({ kind: "variable", name: d.id.name }));
+      }
+      if (declType === AST_NODE_TYPES2.TSTypeAliasDeclaration && !options.ignoreTypes) {
+        return [{ kind: "type", name: decl.id.name }];
+      }
+      if (declType === AST_NODE_TYPES2.TSInterfaceDeclaration && !options.ignoreTypes) {
+        return [{ kind: "interface", name: decl.id.name }];
+      }
+      return [];
+    }
     return {
       ExportNamedDeclaration(node) {
         const decl = node.declaration;
         if (!decl) return;
-        const declType = decl.type;
-        if (declType === AST_NODE_TYPES2.FunctionDeclaration) {
-          const fn = decl;
-          if (fn.id) checkExport(node, "function", fn.id.name);
-        } else if (declType === AST_NODE_TYPES2.ClassDeclaration) {
-          const cls = decl;
-          if (cls.id) checkExport(node, "class", cls.id.name);
-        } else if (declType === AST_NODE_TYPES2.VariableDeclaration) {
-          const varDecl = decl;
-          for (const declarator of varDecl.declarations) {
-            if (declarator.id.type === AST_NODE_TYPES2.Identifier) {
-              checkExport(node, "variable", declarator.id.name);
-            }
-          }
-        } else if (declType === AST_NODE_TYPES2.TSTypeAliasDeclaration && !options.ignoreTypes) {
-          const typeAlias = decl;
-          checkExport(node, "type", typeAlias.id.name);
-        } else if (declType === AST_NODE_TYPES2.TSInterfaceDeclaration && !options.ignoreTypes) {
-          const iface = decl;
-          checkExport(node, "interface", iface.id.name);
+        for (const info of getExportInfo(decl)) {
+          checkExport(node, info.kind, info.name);
         }
       }
     };
@@ -819,21 +830,21 @@ function isImportOrRequire(node) {
   }
   return false;
 }
+function isMemberCall(callee, objectNames, methods) {
+  return callee.object.type === "Identifier" && objectNames.has(callee.object.name) && callee.property.type === "Identifier" && methods.has(callee.property.name);
+}
+var PATH_OBJECTS = /* @__PURE__ */ new Set(["path"]);
+var FS_OBJECTS = /* @__PURE__ */ new Set(["fs", "fsp"]);
 function isInFlaggedContext(node) {
   const parent = node.parent;
   if (!parent) return false;
-  if (parent.type === "CallExpression") {
-    const callee = parent.callee;
-    if (callee.type === "MemberExpression" && callee.object.type === "Identifier" && callee.object.name === "path" && callee.property.type === "Identifier" && PATH_METHODS.has(callee.property.name)) {
-      return true;
-    }
-    if (callee.type === "MemberExpression" && callee.object.type === "Identifier" && (callee.object.name === "fs" || callee.object.name === "fsp") && callee.property.type === "Identifier" && FS_METHODS.has(callee.property.name)) {
-      return true;
-    }
-    if (callee.type === "MemberExpression" && callee.property.type === "Identifier" && STRING_METHODS.has(callee.property.name)) {
-      return true;
-    }
-    return false;
+  if (parent.type !== "CallExpression") return false;
+  const callee = parent.callee;
+  if (callee.type !== "MemberExpression") return false;
+  if (isMemberCall(callee, PATH_OBJECTS, PATH_METHODS)) return true;
+  if (isMemberCall(callee, FS_OBJECTS, FS_METHODS)) return true;
+  if (callee.property.type === "Identifier" && STRING_METHODS.has(callee.property.name)) {
+    return true;
   }
   return false;
 }
@@ -867,6 +878,63 @@ var no_hardcoded_path_separator_default = createRule10({
   }
 });
 
+// src/rules/require-path-normalization.ts
+import { ESLintUtils as ESLintUtils11 } from "@typescript-eslint/utils";
+var createRule11 = ESLintUtils11.RuleCreator(
+  (name) => `https://github.com/harness-engineering/eslint-plugin/blob/main/docs/rules/${name}.md`
+);
+function isRelativeCall(node) {
+  const callee = node.callee;
+  if (callee.type === "Identifier" && callee.name === "relative") {
+    return true;
+  }
+  if (callee.type === "MemberExpression" && callee.object.type === "Identifier" && callee.object.name === "path" && callee.property.type === "Identifier" && callee.property.name === "relative") {
+    return true;
+  }
+  return false;
+}
+function isReplaceMethod(parent) {
+  return parent.type === "MemberExpression" && parent.property.type === "Identifier" && (parent.property.name === "replaceAll" || parent.property.name === "replace");
+}
+function isBackslashNormalizationArg(firstArg) {
+  if (firstArg.type === "Literal" && firstArg.value === "\\") return true;
+  if ("regex" in firstArg && firstArg.type === "Literal") return true;
+  return false;
+}
+function hasNormalization(node) {
+  const parent = node.parent;
+  if (!parent || !isReplaceMethod(parent)) return false;
+  const grandparent = parent.parent;
+  if (grandparent?.type !== "CallExpression" || grandparent.arguments.length < 1) return false;
+  return isBackslashNormalizationArg(grandparent.arguments[0]);
+}
+var require_path_normalization_default = createRule11({
+  name: "require-path-normalization",
+  meta: {
+    type: "problem",
+    docs: {
+      description: 'Require path.relative() results to be normalized with .replaceAll("\\\\", "/") for cross-platform safety'
+    },
+    messages: {
+      missingNormalization: "path.relative() result must be normalized with .replaceAll('\\\\', '/') for cross-platform compatibility."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (!isRelativeCall(node)) return;
+        if (hasNormalization(node)) return;
+        context.report({
+          node,
+          messageId: "missingNormalization"
+        });
+      }
+    };
+  }
+});
+
 // src/rules/index.ts
 var rules = {
   "enforce-doc-exports": enforce_doc_exports_default,
@@ -878,7 +946,8 @@ var rules = {
   "no-sync-io-in-async": no_sync_io_in_async_default,
   "no-unbounded-array-chains": no_unbounded_array_chains_default,
   "no-unix-shell-command": no_unix_shell_command_default,
-  "require-boundary-schema": require_boundary_schema_default
+  "require-boundary-schema": require_boundary_schema_default,
+  "require-path-normalization": require_path_normalization_default
 };
 
 // src/index.ts
@@ -902,7 +971,8 @@ var plugin = {
         "@harness-engineering/require-boundary-schema": "warn",
         "@harness-engineering/enforce-doc-exports": "warn",
         "@harness-engineering/no-unix-shell-command": "warn",
-        "@harness-engineering/no-hardcoded-path-separator": "warn"
+        "@harness-engineering/no-hardcoded-path-separator": "warn",
+        "@harness-engineering/require-path-normalization": "warn"
       }
     },
     strict: {
@@ -918,7 +988,8 @@ var plugin = {
         "@harness-engineering/require-boundary-schema": "error",
         "@harness-engineering/enforce-doc-exports": "error",
         "@harness-engineering/no-unix-shell-command": "error",
-        "@harness-engineering/no-hardcoded-path-separator": "error"
+        "@harness-engineering/no-hardcoded-path-separator": "error",
+        "@harness-engineering/require-path-normalization": "error"
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harness-engineering/eslint-plugin",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "ESLint plugin for harness engineering architectural constraints",
   "type": "module",
   "main": "./dist/index.js",