@harness-engineering/eslint-plugin 0.1.1 → 0.2.0

package/dist/index.js

@@ -1,46 +1,932 @@
-// src/index.ts
-import { rules } from './rules';
-// Define the plugin object
-const plugin = {
-    meta: {
-        name: '@harness-engineering/eslint-plugin',
-        version: '0.1.0',
-    },
-    rules,
-    configs: {
-        recommended: {
-            plugins: {
-                get '@harness-engineering'() {
-                    return plugin;
-                },
-            },
-            rules: {
-                '@harness-engineering/no-layer-violation': 'error',
-                '@harness-engineering/no-circular-deps': 'error',
-                '@harness-engineering/no-forbidden-imports': 'error',
-                '@harness-engineering/require-boundary-schema': 'warn',
-                '@harness-engineering/enforce-doc-exports': 'warn',
-            },
-        },
-        strict: {
-            plugins: {
-                get '@harness-engineering'() {
-                    return plugin;
-                },
-            },
-            rules: {
-                '@harness-engineering/no-layer-violation': 'error',
-                '@harness-engineering/no-circular-deps': 'error',
-                '@harness-engineering/no-forbidden-imports': 'error',
-                '@harness-engineering/require-boundary-schema': 'error',
-                '@harness-engineering/enforce-doc-exports': 'error',
-            },
+// src/rules/enforce-doc-exports.ts
+import { ESLintUtils, AST_NODE_TYPES as AST_NODE_TYPES2 } from "@typescript-eslint/utils";
+
+// src/utils/ast-helpers.ts
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+function hasJSDocComment(node, sourceCode) {
+  if (!node.range) return false;
+  const textBefore = sourceCode.slice(0, node.range[0]);
+  const lines = textBefore.split("\n");
+  let foundJSDoc = false;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i]?.trim() ?? "";
+    if (line === "") continue;
+    if (line.endsWith("*/")) {
+      const startIdx = textBefore.lastIndexOf("/**");
+      const endIdx = textBefore.lastIndexOf("*/");
+      if (startIdx !== -1 && endIdx > startIdx) {
+        foundJSDoc = true;
+      }
+      break;
+    }
+    break;
+  }
+  return foundJSDoc;
+}
+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);
+        }
+      }
+    }
+  }
+  visit(body);
+  return found;
+}
+function isMarkedInternal(node, sourceCode) {
+  if (!node.range) return false;
+  const textBefore = sourceCode.slice(0, node.range[0]);
+  const lastComment = textBefore.lastIndexOf("/**");
+  if (lastComment === -1) return false;
+  const commentEnd = textBefore.lastIndexOf("*/");
+  if (commentEnd === -1 || commentEnd < lastComment) return false;
+  const comment = textBefore.slice(lastComment, commentEnd + 2);
+  return comment.includes("@internal");
+}
+
+// src/rules/enforce-doc-exports.ts
+var createRule = ESLintUtils.RuleCreator(
+  (name) => `https://github.com/harness-engineering/eslint-plugin/blob/main/docs/rules/${name}.md`
+);
+var enforce_doc_exports_default = createRule({
+  name: "enforce-doc-exports",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Require JSDoc comments on public exports"
+    },
+    messages: {
+      missingJSDoc: 'Exported {{kind}} "{{name}}" is missing JSDoc documentation'
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          ignoreTypes: { type: "boolean", default: false },
+          ignoreInternal: { type: "boolean", default: true }
         },
+        additionalProperties: false
+      }
+    ]
+  },
+  defaultOptions: [{ ignoreTypes: false, ignoreInternal: true }],
+  create(context, [options]) {
+    const sourceCode = context.sourceCode.getText();
+    function checkExport(node, kind, name) {
+      if (options.ignoreInternal && isMarkedInternal(node, sourceCode)) {
+        return;
+      }
+      if (!hasJSDocComment(node, sourceCode)) {
+        context.report({
+          node,
+          messageId: "missingJSDoc",
+          data: { kind, name }
+        });
+      }
+    }
+    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);
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-circular-deps.ts
+import { ESLintUtils as ESLintUtils2 } from "@typescript-eslint/utils";
+import * as path from "path";
+var createRule2 = ESLintUtils2.RuleCreator(
+  (name) => `https://github.com/harness-engineering/eslint-plugin/blob/main/docs/rules/${name}.md`
+);
+var importGraph = /* @__PURE__ */ new Map();
+function addEdge(from, to) {
+  if (!importGraph.has(from)) {
+    importGraph.set(from, /* @__PURE__ */ new Set());
+  }
+  importGraph.get(from).add(to);
+}
+function detectCycle(from, to) {
+  const visited = /* @__PURE__ */ new Set();
+  const cyclePath = [to];
+  function dfs(current) {
+    if (current === from) {
+      return true;
+    }
+    if (visited.has(current)) {
+      return false;
+    }
+    visited.add(current);
+    const deps = importGraph.get(current);
+    if (deps) {
+      for (const dep of deps) {
+        cyclePath.push(dep);
+        if (dfs(dep)) {
+          return true;
+        }
+        cyclePath.pop();
+      }
+    }
+    return false;
+  }
+  if (dfs(to)) {
+    return [from, ...cyclePath];
+  }
+  return null;
+}
+function normalizePath(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const srcIndex = normalized.indexOf("/src/");
+  if (srcIndex !== -1) {
+    return normalized.slice(srcIndex + 1);
+  }
+  return path.basename(filePath);
+}
+var no_circular_deps_default = createRule2({
+  name: "no-circular-deps",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Detect circular import dependencies"
+    },
+    messages: {
+      circularDep: "Circular dependency detected: {{cycle}}"
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const currentFile = normalizePath(context.filename);
+    return {
+      ImportDeclaration(node) {
+        const importPath = node.source.value;
+        if (!importPath.startsWith(".")) {
+          return;
+        }
+        const importingDir = path.dirname(context.filename);
+        const resolvedPath = path.resolve(importingDir, importPath);
+        const normalizedImport = normalizePath(resolvedPath);
+        const cycle = detectCycle(currentFile, normalizedImport);
+        if (cycle) {
+          context.report({
+            node,
+            messageId: "circularDep",
+            data: {
+              cycle: cycle.map((f) => path.basename(f)).join(" \u2192 ")
+            }
+          });
+        }
+        addEdge(currentFile, normalizedImport);
+      }
+    };
+  }
+});
+
+// src/rules/no-forbidden-imports.ts
+import { ESLintUtils as ESLintUtils3 } from "@typescript-eslint/utils";
+
+// src/utils/config-loader.ts
+import * as fs from "fs";
+import * as path2 from "path";
+
+// src/utils/schema.ts
+import { z } from "zod";
+var LayerSchema = z.object({
+  name: z.string(),
+  pattern: z.string(),
+  allowedDependencies: z.array(z.string())
+});
+var ForbiddenImportSchema = z.object({
+  from: z.string(),
+  disallow: z.array(z.string()),
+  message: z.string().optional()
+});
+var BoundaryConfigSchema = z.object({
+  requireSchema: z.array(z.string())
+});
+var HarnessConfigSchema = z.object({
+  version: z.literal(1),
+  layers: z.array(LayerSchema).optional(),
+  forbiddenImports: z.array(ForbiddenImportSchema).optional(),
+  boundaries: BoundaryConfigSchema.optional()
+});
+
+// src/utils/config-loader.ts
+var CONFIG_FILENAME = "harness.config.json";
+var cachedConfig = null;
+var cachedConfigPath = null;
+function findConfigFile(startDir) {
+  let currentDir = path2.resolve(startDir);
+  const root = path2.parse(currentDir).root;
+  while (currentDir !== root) {
+    const configPath = path2.join(currentDir, CONFIG_FILENAME);
+    if (fs.existsSync(configPath)) {
+      return configPath;
+    }
+    currentDir = path2.dirname(currentDir);
+  }
+  return null;
+}
+function getConfig(filePath) {
+  const configPath = findConfigFile(path2.dirname(filePath));
+  if (!configPath) {
+    return null;
+  }
+  if (cachedConfigPath === configPath && cachedConfig) {
+    return cachedConfig;
+  }
+  try {
+    const content = fs.readFileSync(configPath, "utf-8");
+    const parsed = HarnessConfigSchema.safeParse(JSON.parse(content));
+    if (!parsed.success) {
+      return null;
+    }
+    cachedConfig = parsed.data;
+    cachedConfigPath = configPath;
+    return cachedConfig;
+  } catch {
+    return null;
+  }
+}
+
+// src/utils/path-utils.ts
+import * as path3 from "path";
+import { minimatch } from "minimatch";
+function resolveImportPath(importPath, importingFile) {
+  if (!importPath.startsWith(".")) {
+    return importPath;
+  }
+  const importingDir = path3.dirname(importingFile);
+  const resolved = path3.resolve(importingDir, importPath);
+  const normalized = resolved.replace(/\\/g, "/");
+  const srcIndex = normalized.indexOf("/src/");
+  if (srcIndex !== -1) {
+    return normalized.slice(srcIndex + 1);
+  }
+  return importPath;
+}
+function matchesPattern(filePath, pattern) {
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  const normalizedPattern = pattern.replace(/\\/g, "/");
+  return minimatch(normalizedPath, normalizedPattern, { matchBase: false });
+}
+function getLayerForFile(filePath, layers) {
+  for (const layer of layers) {
+    if (matchesPattern(filePath, layer.pattern)) {
+      return layer.name;
+    }
+  }
+  return null;
+}
+function getLayerByName(name, layers) {
+  return layers.find((l) => l.name === name);
+}
+function normalizePath2(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const srcIndex = normalized.indexOf("/src/");
+  if (srcIndex !== -1) {
+    return normalized.slice(srcIndex + 1);
+  }
+  return filePath;
+}
+
+// src/rules/no-forbidden-imports.ts
+var createRule3 = ESLintUtils3.RuleCreator(
+  (name) => `https://github.com/harness-engineering/eslint-plugin/blob/main/docs/rules/${name}.md`
+);
+var no_forbidden_imports_default = createRule3({
+  name: "no-forbidden-imports",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Block forbidden imports based on configurable patterns"
+    },
+    messages: {
+      forbiddenImport: "{{message}}"
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const config = getConfig(context.filename);
+    if (!config?.forbiddenImports?.length) {
+      return {};
+    }
+    const filePath = normalizePath2(context.filename);
+    const applicableRules = config.forbiddenImports.filter(
+      (rule) => matchesPattern(filePath, rule.from)
+    );
+    if (applicableRules.length === 0) {
+      return {};
+    }
+    return {
+      ImportDeclaration(node) {
+        const importPath = node.source.value;
+        const resolvedImport = resolveImportPath(importPath, context.filename);
+        for (const rule of applicableRules) {
+          for (const disallowed of rule.disallow) {
+            const isMatch = importPath === disallowed || matchesPattern(resolvedImport, disallowed) || matchesPattern(importPath, disallowed);
+            if (isMatch) {
+              context.report({
+                node,
+                messageId: "forbiddenImport",
+                data: {
+                  message: rule.message || `Import "${importPath}" is forbidden in files matching "${rule.from}"`
+                }
+              });
+              return;
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-layer-violation.ts
+import { ESLintUtils as ESLintUtils4 } from "@typescript-eslint/utils";
+var createRule4 = ESLintUtils4.RuleCreator(
+  (name) => `https://github.com/harness-engineering/eslint-plugin/blob/main/docs/rules/${name}.md`
+);
+var no_layer_violation_default = createRule4({
+  name: "no-layer-violation",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce layer boundary imports"
+    },
+    messages: {
+      layerViolation: 'Layer "{{fromLayer}}" cannot import from layer "{{toLayer}}"'
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const config = getConfig(context.filename);
+    if (!config?.layers?.length) {
+      return {};
+    }
+    const filePath = normalizePath2(context.filename);
+    const currentLayer = getLayerForFile(filePath, config.layers);
+    if (!currentLayer) {
+      return {};
+    }
+    const currentLayerDef = getLayerByName(currentLayer, config.layers);
+    if (!currentLayerDef) {
+      return {};
+    }
+    return {
+      ImportDeclaration(node) {
+        const importPath = node.source.value;
+        if (!importPath.startsWith(".")) {
+          return;
+        }
+        const resolvedImport = resolveImportPath(importPath, context.filename);
+        const importLayer = getLayerForFile(resolvedImport, config.layers);
+        if (!importLayer) {
+          return;
+        }
+        if (importLayer !== currentLayer && !currentLayerDef.allowedDependencies.includes(importLayer)) {
+          context.report({
+            node,
+            messageId: "layerViolation",
+            data: {
+              fromLayer: currentLayer,
+              toLayer: importLayer
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-nested-loops-in-critical.ts
+import { ESLintUtils as ESLintUtils5 } from "@typescript-eslint/utils";
+var createRule5 = ESLintUtils5.RuleCreator(
+  (name) => `https://github.com/harness-engineering/eslint-plugin/blob/main/docs/rules/${name}.md`
+);
+var no_nested_loops_in_critical_default = createRule5({
+  name: "no-nested-loops-in-critical",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow nested loops in @perf-critical functions"
+    },
+    messages: {
+      nestedLoopInCritical: "Nested loop in @perf-critical code \u2014 consider alternative algorithm"
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const sourceText = context.sourceCode.getText();
+    if (!sourceText.includes("@perf-critical")) {
+      return {};
+    }
+    const criticalStack = [];
+    let loopDepth = 0;
+    function isCritical() {
+      return criticalStack.length > 0 && criticalStack[criticalStack.length - 1] === true;
+    }
+    function hasCriticalAnnotation(node) {
+      const target = node.parent?.type === "ExportNamedDeclaration" || node.parent?.type === "VariableDeclaration" ? node.parent : node;
+      const startLine = target.loc.start.line;
+      const lines = sourceText.split("\n");
+      for (let i = Math.max(0, startLine - 2); i < startLine; i++) {
+        if (lines[i]?.includes("@perf-critical")) return true;
+      }
+      return false;
+    }
+    function enterFunction(node) {
+      criticalStack.push(hasCriticalAnnotation(node));
+      loopDepth = 0;
+    }
+    function exitFunction() {
+      criticalStack.pop();
+      loopDepth = 0;
+    }
+    function enterLoop(node) {
+      if (!isCritical()) return;
+      loopDepth++;
+      if (loopDepth > 1) {
+        context.report({ node, messageId: "nestedLoopInCritical" });
+      }
+    }
+    function exitLoop() {
+      if (!isCritical()) return;
+      loopDepth--;
+    }
+    return {
+      FunctionDeclaration: enterFunction,
+      "FunctionDeclaration:exit": exitFunction,
+      FunctionExpression: enterFunction,
+      "FunctionExpression:exit": exitFunction,
+      ArrowFunctionExpression: enterFunction,
+      "ArrowFunctionExpression:exit": exitFunction,
+      ForStatement: enterLoop,
+      "ForStatement:exit": exitLoop,
+      ForInStatement: enterLoop,
+      "ForInStatement:exit": exitLoop,
+      ForOfStatement: enterLoop,
+      "ForOfStatement:exit": exitLoop,
+      WhileStatement: enterLoop,
+      "WhileStatement:exit": exitLoop,
+      DoWhileStatement: enterLoop,
+      "DoWhileStatement:exit": exitLoop
+    };
+  }
+});
+
+// src/rules/no-sync-io-in-async.ts
+import { ESLintUtils as ESLintUtils6 } from "@typescript-eslint/utils";
+var createRule6 = ESLintUtils6.RuleCreator(
+  (name) => `https://github.com/harness-engineering/eslint-plugin/blob/main/docs/rules/${name}.md`
+);
+var SYNC_FS_METHODS = /* @__PURE__ */ new Set([
+  "readFileSync",
+  "writeFileSync",
+  "existsSync",
+  "readdirSync",
+  "statSync",
+  "mkdirSync",
+  "unlinkSync",
+  "copyFileSync",
+  "renameSync",
+  "accessSync"
+]);
+var no_sync_io_in_async_default = createRule6({
+  name: "no-sync-io-in-async",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow synchronous fs operations inside async functions"
+    },
+    messages: {
+      syncIoInAsync: "Use async fs methods instead of '{{name}}' in async functions"
     },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    let asyncDepth = 0;
+    function enterFunction(node) {
+      if (node.async) {
+        asyncDepth++;
+      }
+    }
+    function exitFunction(node) {
+      if (node.async) {
+        asyncDepth--;
+      }
+    }
+    return {
+      FunctionDeclaration: enterFunction,
+      "FunctionDeclaration:exit": exitFunction,
+      FunctionExpression: enterFunction,
+      "FunctionExpression:exit": exitFunction,
+      ArrowFunctionExpression: enterFunction,
+      "ArrowFunctionExpression:exit": exitFunction,
+      CallExpression(node) {
+        if (asyncDepth === 0) return;
+        let name;
+        if (node.callee.type === "Identifier" && SYNC_FS_METHODS.has(node.callee.name)) {
+          name = node.callee.name;
+        }
+        if (node.callee.type === "MemberExpression" && node.callee.property.type === "Identifier" && SYNC_FS_METHODS.has(node.callee.property.name)) {
+          name = node.callee.property.name;
+        }
+        if (name) {
+          context.report({
+            node,
+            messageId: "syncIoInAsync",
+            data: { name }
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-unbounded-array-chains.ts
+import { ESLintUtils as ESLintUtils7 } from "@typescript-eslint/utils";
+var createRule7 = ESLintUtils7.RuleCreator(
+  (name) => `https://github.com/harness-engineering/eslint-plugin/blob/main/docs/rules/${name}.md`
+);
+var ARRAY_METHODS = /* @__PURE__ */ new Set([
+  "filter",
+  "map",
+  "reduce",
+  "sort",
+  "flatMap",
+  "find",
+  "some",
+  "every",
+  "forEach"
+]);
+var no_unbounded_array_chains_default = createRule7({
+  name: "no-unbounded-array-chains",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow 3+ chained array operations"
+    },
+    messages: {
+      unboundedArrayChain: "3+ chained array operations \u2014 consider a single-pass approach"
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      "CallExpression > MemberExpression.callee"(node) {
+        if (node.property.type !== "Identifier" || !ARRAY_METHODS.has(node.property.name)) {
+          return;
+        }
+        const callExpr = node.parent;
+        if (callExpr.parent && callExpr.parent.type === "MemberExpression" && callExpr.parent.property.type === "Identifier" && ARRAY_METHODS.has(callExpr.parent.property.name)) {
+          return;
+        }
+        let chainLength = 1;
+        let current = node;
+        while (true) {
+          const memberExpr = current;
+          const obj = memberExpr.object;
+          if (obj.type === "CallExpression" && obj.callee.type === "MemberExpression" && obj.callee.property.type === "Identifier" && ARRAY_METHODS.has(obj.callee.property.name)) {
+            chainLength++;
+            current = obj.callee;
+          } else {
+            break;
+          }
+        }
+        if (chainLength >= 3) {
+          context.report({
+            node: callExpr,
+            messageId: "unboundedArrayChain"
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/require-boundary-schema.ts
+import { ESLintUtils as ESLintUtils8, AST_NODE_TYPES as AST_NODE_TYPES3 } from "@typescript-eslint/utils";
+var createRule8 = ESLintUtils8.RuleCreator(
+  (name) => `https://github.com/harness-engineering/eslint-plugin/blob/main/docs/rules/${name}.md`
+);
+var require_boundary_schema_default = createRule8({
+  name: "require-boundary-schema",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require Zod schema validation at API boundaries"
+    },
+    messages: {
+      missingSchema: 'Exported function "{{name}}" at API boundary must validate input with Zod schema'
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const config = getConfig(context.filename);
+    if (!config?.boundaries?.requireSchema?.length) {
+      return {};
+    }
+    const filePath = normalizePath2(context.filename);
+    const isBoundaryFile = config.boundaries.requireSchema.some(
+      (pattern) => matchesPattern(filePath, pattern)
+    );
+    if (!isBoundaryFile) {
+      return {};
+    }
+    return {
+      ExportNamedDeclaration(node) {
+        const decl = node.declaration;
+        if (!decl || decl.type !== AST_NODE_TYPES3.FunctionDeclaration) {
+          return;
+        }
+        const fn = decl;
+        if (!fn.id || !fn.body) return;
+        if (!hasZodValidation(fn.body)) {
+          context.report({
+            node: fn,
+            messageId: "missingSchema",
+            data: { name: fn.id.name }
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-unix-shell-command.ts
+import { ESLintUtils as ESLintUtils9 } from "@typescript-eslint/utils";
+var createRule9 = ESLintUtils9.RuleCreator(
+  (name) => `https://github.com/harness-engineering/eslint-plugin/blob/main/docs/rules/${name}.md`
+);
+var UNIX_COMMANDS = ["rm", "cp", "mv", "mkdir", "chmod", "chown"];
+var UNIX_COMMAND_PATTERN = new RegExp(
+  `(?:^|[;&|]\\s*)(?:/(?:usr/)?(?:bin|sbin)/)?(?:${UNIX_COMMANDS.join("|")})(?:\\s|$)`
+);
+var FLAGGED_FUNCTIONS = /* @__PURE__ */ new Set(["exec", "execSync"]);
+var no_unix_shell_command_default = createRule9({
+  name: "no-unix-shell-command",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow exec/execSync calls with Unix-specific shell commands"
+    },
+    messages: {
+      unixShellCommand: "Avoid Unix-specific shell commands in exec/execSync. Use Node.js fs APIs or execFile with cross-platform binaries instead."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node) {
+        let functionName;
+        if (node.callee.type === "Identifier" && FLAGGED_FUNCTIONS.has(node.callee.name)) {
+          functionName = node.callee.name;
+        }
+        if (node.callee.type === "MemberExpression" && node.callee.property.type === "Identifier" && FLAGGED_FUNCTIONS.has(node.callee.property.name)) {
+          functionName = node.callee.property.name;
+        }
+        if (!functionName) return;
+        const firstArg = node.arguments[0];
+        if (!firstArg) return;
+        let commandString;
+        if (firstArg.type === "Literal" && typeof firstArg.value === "string") {
+          commandString = firstArg.value;
+        } else if (firstArg.type === "TemplateLiteral" && firstArg.quasis.length > 0) {
+          commandString = firstArg.quasis.map((q) => q.value.raw).join(" ");
+        }
+        if (commandString && UNIX_COMMAND_PATTERN.test(commandString)) {
+          context.report({
+            node,
+            messageId: "unixShellCommand"
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-hardcoded-path-separator.ts
+import { ESLintUtils as ESLintUtils10 } from "@typescript-eslint/utils";
+var createRule10 = ESLintUtils10.RuleCreator(
+  (name) => `https://github.com/harness-engineering/eslint-plugin/blob/main/docs/rules/${name}.md`
+);
+var HARDCODED_SEPARATOR_PATTERN = /\/[a-zA-Z_][a-zA-Z0-9_-]*\//;
+var URL_PREFIXES = ["http://", "https://", "ftp://", "file://"];
+var PATH_METHODS = /* @__PURE__ */ new Set([
+  "join",
+  "resolve",
+  "normalize",
+  "relative",
+  "dirname",
+  "basename",
+  "extname",
+  "parse",
+  "format",
+  "isAbsolute"
+]);
+var FS_METHODS = /* @__PURE__ */ new Set([
+  "readFileSync",
+  "writeFileSync",
+  "readFile",
+  "writeFile",
+  "existsSync",
+  "exists",
+  "statSync",
+  "stat",
+  "lstatSync",
+  "lstat",
+  "readdirSync",
+  "readdir",
+  "mkdirSync",
+  "mkdir",
+  "unlinkSync",
+  "unlink",
+  "rmSync",
+  "rm",
+  "cpSync",
+  "cp",
+  "copyFileSync",
+  "copyFile",
+  "renameSync",
+  "rename",
+  "accessSync",
+  "access",
+  "chmodSync",
+  "chmod"
+]);
+var STRING_METHODS = /* @__PURE__ */ new Set(["indexOf", "includes", "startsWith", "endsWith"]);
+function isUrlString(value) {
+  return URL_PREFIXES.some((prefix) => value.startsWith(prefix));
+}
+function isImportOrRequire(node) {
+  const parent = node.parent;
+  if (!parent) return false;
+  if (parent.type === "ImportDeclaration" && parent.source === node) return true;
+  if (parent.type === "ImportExpression" && parent.source === node) return true;
+  if (parent.type === "CallExpression" && parent.callee.type === "Identifier" && parent.callee.name === "require" && parent.arguments[0] === node) {
+    return true;
+  }
+  return false;
+}
+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;
+  }
+  return false;
+}
+var no_hardcoded_path_separator_default = createRule10({
+  name: "no-hardcoded-path-separator",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow hardcoded Unix path separators in path/fs method calls and string comparisons"
+    },
+    messages: {
+      hardcodedPathSeparator: "Avoid hardcoded Unix path separators. Use path.join(), path.sep, or path.posix/path.win32 for cross-platform compatibility."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      Literal(node) {
+        if (typeof node.value !== "string") return;
+        if (!HARDCODED_SEPARATOR_PATTERN.test(node.value)) return;
+        if (isUrlString(node.value)) return;
+        if (isImportOrRequire(node)) return;
+        if (!isInFlaggedContext(node)) return;
+        context.report({
+          node,
+          messageId: "hardcodedPathSeparator"
+        });
+      }
+    };
+  }
+});
+
+// src/rules/index.ts
+var rules = {
+  "enforce-doc-exports": enforce_doc_exports_default,
+  "no-circular-deps": no_circular_deps_default,
+  "no-forbidden-imports": no_forbidden_imports_default,
+  "no-hardcoded-path-separator": no_hardcoded_path_separator_default,
+  "no-layer-violation": no_layer_violation_default,
+  "no-nested-loops-in-critical": no_nested_loops_in_critical_default,
+  "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
+};
+
+// src/index.ts
+var plugin = {
+  meta: {
+    name: "@harness-engineering/eslint-plugin",
+    version: "0.1.0"
+  },
+  rules,
+  configs: {
+    recommended: {
+      plugins: {
+        get "@harness-engineering"() {
+          return plugin;
+        }
+      },
+      rules: {
+        "@harness-engineering/no-layer-violation": "error",
+        "@harness-engineering/no-circular-deps": "error",
+        "@harness-engineering/no-forbidden-imports": "error",
+        "@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"
+      }
+    },
+    strict: {
+      plugins: {
+        get "@harness-engineering"() {
+          return plugin;
+        }
+      },
+      rules: {
+        "@harness-engineering/no-layer-violation": "error",
+        "@harness-engineering/no-circular-deps": "error",
+        "@harness-engineering/no-forbidden-imports": "error",
+        "@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"
+      }
+    }
+  }
+};
+var index_default = plugin;
+var configs = plugin.configs;
+export {
+  configs,
+  index_default as default,
+  rules
 };
-// ESM default export
-export default plugin;
-// Named exports for flexibility
-export { rules };
-export const configs = plugin.configs;
-//# sourceMappingURL=index.js.map