eslint-plugin-reliability 3.0.0

package/README.md

@@ -0,0 +1,159 @@
+<p align="center">
+  <a href="https://eslint.interlace.tools" target="blank"><img src="https://eslint.interlace.tools/eslint-interlace-logo-light.svg" alt="ESLint Interlace Logo" width="120" /></a>
+</p>
+
+<p align="center">
+  Error handling, null safety, and runtime reliability rules for robust applications.
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/eslint-plugin-reliability" target="_blank"><img src="https://img.shields.io/npm/v/eslint-plugin-reliability.svg" alt="NPM Version" /></a>
+  <a href="https://www.npmjs.com/package/eslint-plugin-reliability" target="_blank"><img src="https://img.shields.io/npm/dm/eslint-plugin-reliability.svg" alt="NPM Downloads" /></a>
+  <a href="https://opensource.org/licenses/MIT" target="_blank"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="Package License" /></a>
+</p>
+
+## Description
+
+This plugin enforces reliable code patterns by detecting unhandled promises, silent error swallowing, missing null checks, and network timeouts. It helps teams build applications that fail gracefully and recover predictably.
+
+## Philosophy
+
+**Interlace** fosters **strength through integration**. Reliability isn't optional — it's foundational. These rules catch common runtime failure patterns before they cause incidents in production.
+
+## Getting Started
+
+- To check out the [guide](https://eslint.interlace.tools/docs/reliability), visit [eslint.interlace.tools](https://eslint.interlace.tools). 📚
+
+```bash
+npm install eslint-plugin-reliability --save-dev
+```
+
+## ⚙️ Configuration Presets
+
+| Preset        | Description                                   |
+| :------------ | :-------------------------------------------- |
+| `recommended` | Balanced reliability checks for most projects |
+
+---
+
+## 🏢 Usage Example
+
+```js
+// eslint.config.js
+import reliability from 'eslint-plugin-reliability';
+
+export default [reliability.configs.recommended];
+```
+
+---
+
+## Rules
+
+### Error Handling
+
+| Rule                                                                 | Description                                   | 💼  | ⚠️  |
+| :------------------------------------------------------------------- | :-------------------------------------------- | :-: | :-: |
+| [no-unhandled-promise](./docs/rules/no-unhandled-promise.md)         | Detect unhandled promise rejections           |     |     |
+| [no-silent-errors](./docs/rules/no-silent-errors.md)                 | Detect empty catch blocks that swallow errors | 💼  | ⚠️  |
+| [no-missing-error-context](./docs/rules/no-missing-error-context.md) | Require error context when re-throwing        |     |     |
+| [error-message](./docs/rules/error-message.md)                       | Require meaningful error messages             |     |     |
+
+### Runtime Safety
+
+| Rule                                                                 | Description                                    | 💼  | ⚠️  |
+| :------------------------------------------------------------------- | :--------------------------------------------- | :-: | :-: |
+| [no-missing-null-checks](./docs/rules/no-missing-null-checks.md)     | Detect potential null/undefined dereferences   | 💼  | ⚠️  |
+| [no-unsafe-type-narrowing](./docs/rules/no-unsafe-type-narrowing.md) | Detect unsafe type narrowing patterns          |     |     |
+| [require-network-timeout](./docs/rules/require-network-timeout.md)   | Require timeouts on network requests           | 💼  |     |
+| [no-await-in-loop](./docs/rules/no-await-in-loop.md)                 | Detect sequential await in loops (performance) |     |     |
+
+**Legend**: 💼 Recommended | ⚠️ Warns (not error)
+
+---
+
+## Why These Rules?
+
+### `no-silent-errors`
+
+Empty catch blocks hide errors, making debugging impossible.
+
+```ts
+// ❌ Bad: Silent error swallowing
+try {
+  await processPayment(order);
+} catch (e) {
+  // Error is silently ignored!
+}
+
+// ✅ Good: Handle or log the error
+try {
+  await processPayment(order);
+} catch (e) {
+  logger.error('Payment processing failed', { orderId: order.id, error: e });
+  throw new PaymentError('Payment failed', { cause: e });
+}
+```
+
+### `no-missing-null-checks`
+
+Catches potential `null` or `undefined` dereferences.
+
+```ts
+// ❌ Bad: Potential runtime error
+function greet(user: User | null) {
+  return `Hello, ${user.name}`; // TypeError if user is null!
+}
+
+// ✅ Good: Null-safe access
+function greet(user: User | null) {
+  return user ? `Hello, ${user.name}` : 'Hello, guest';
+}
+```
+
+### `require-network-timeout`
+
+Network requests without timeouts can hang indefinitely.
+
+```ts
+// ❌ Bad: No timeout, can hang forever
+const response = await fetch('/api/data');
+
+// ✅ Good: Request with timeout
+const controller = new AbortController();
+const timeoutId = setTimeout(() => controller.abort(), 5000);
+
+const response = await fetch('/api/data', {
+  signal: controller.signal,
+});
+clearTimeout(timeoutId);
+```
+
+### `no-await-in-loop`
+
+Sequential awaits in loops cause N+1 performance issues.
+
+```ts
+// ❌ Bad: Sequential requests (slow)
+for (const id of userIds) {
+  const user = await fetchUser(id); // N sequential requests
+  results.push(user);
+}
+
+// ✅ Good: Parallel requests (fast)
+const results = await Promise.all(userIds.map((id) => fetchUser(id)));
+```
+
+---
+
+## 🔗 Related ESLint Plugins
+
+Part of the **Interlace ESLint Ecosystem** — AI-native quality plugins with LLM-optimized error messages:
+
+| Plugin                                                                                         | Description                         |
+| :--------------------------------------------------------------------------------------------- | :---------------------------------- |
+| [`eslint-plugin-operability`](https://www.npmjs.com/package/eslint-plugin-operability)         | Production readiness & debug code   |
+| [`eslint-plugin-maintainability`](https://www.npmjs.com/package/eslint-plugin-maintainability) | Cognitive complexity & code quality |
+
+## 📄 License
+
+MIT © [Ofri Peretz](https://github.com/ofri-peretz)

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "eslint-plugin-reliability",
+  "version": "3.0.0",
+  "description": "ESLint rules for runtime stability, fault tolerance, and type safety.",
+  "type": "commonjs",
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "default": "./src/index.js"
+    }
+  },
+  "author": "Ofri Peretz <ofriperetzdev@gmail.com>",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "src/",
+    "dist/",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "keywords": [
+    "eslint",
+    "eslint-plugin",
+    "interlace-quality",
+    "reliability",
+    "error-handling",
+    "type-safety",
+    "llm-optimized"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0",
+    "@interlace/eslint-devkit": "*"
+  },
+  "devDependencies": {
+    "@typescript-eslint/parser": "^8.46.2",
+    "@typescript-eslint/rule-tester": "^8.46.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ofri-peretz/eslint",
+    "directory": "packages/eslint-plugin-reliability"
+  },
+  "homepage": "https://github.com/ofri-peretz/eslint/tree/main/packages/eslint-plugin-reliability#readme",
+  "bugs": {
+    "url": "https://github.com/ofri-peretz/eslint/issues"
+  }
+}

package/src/index.d.ts

@@ -0,0 +1,180 @@
+/**
+ * Copyright (c) 2025 Ofri Peretz
+ * Licensed under the MIT License. Use of this source code is governed by the
+ * MIT license that can be found in the LICENSE file.
+ */
+import type { TSESLint } from '@interlace/eslint-devkit';
+export declare const rules: {
+    'no-unhandled-promise': TSESLint.RuleModule<"unhandledPromise" | "addCatch" | "useTryCatch" | "useAwait", [(import("./rules/error-handling/no-unhandled-promise").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+        name: string;
+    };
+    'no-silent-errors': TSESLint.RuleModule<"silentError" | "addErrorLogging" | "addErrorHandling" | "rethrowError", [(import("./rules/error-handling/no-silent-errors").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+        name: string;
+    };
+    'no-missing-error-context': TSESLint.RuleModule<"missingErrorContext" | "addErrorMessage" | "addErrorStack" | "useErrorClass", [(import("./rules/error-handling/no-missing-error-context").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+        name: string;
+    };
+    'error-message': TSESLint.RuleModule<"addErrorMessage" | "missingErrorMessage", [(import("./rules/error-handling/error-message").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+        name: string;
+    };
+    'no-missing-null-checks': TSESLint.RuleModule<"missingNullCheck" | "useOptionalChaining" | "useNullishCoalescing" | "addExplicitCheck", [(import("./rules/reliability/no-missing-null-checks").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+        name: string;
+    };
+    'no-unsafe-type-narrowing': TSESLint.RuleModule<"unsafeTypeNarrowing" | "useTypeGuard" | "useProperNarrowing" | "validateBeforeAssert", [(import("./rules/reliability/no-unsafe-type-narrowing").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+        name: string;
+    };
+    'require-network-timeout': TSESLint.RuleModule<"violationDetected", [(import("./rules/reliability/require-network-timeout").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+        name: string;
+    };
+    'no-await-in-loop': TSESLint.RuleModule<"awaitInLoop" | "suggestPromiseAll" | "suggestConcurrent" | "considerSequential" | "asyncLoopPattern", [(import("./rules/reliability/no-await-in-loop").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+        name: string;
+    };
+    'error-handling/no-unhandled-promise': TSESLint.RuleModule<"unhandledPromise" | "addCatch" | "useTryCatch" | "useAwait", [(import("./rules/error-handling/no-unhandled-promise").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+        name: string;
+    };
+    'error-handling/no-silent-errors': TSESLint.RuleModule<"silentError" | "addErrorLogging" | "addErrorHandling" | "rethrowError", [(import("./rules/error-handling/no-silent-errors").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+        name: string;
+    };
+    'error-handling/no-missing-error-context': TSESLint.RuleModule<"missingErrorContext" | "addErrorMessage" | "addErrorStack" | "useErrorClass", [(import("./rules/error-handling/no-missing-error-context").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+        name: string;
+    };
+    'error-handling/error-message': TSESLint.RuleModule<"addErrorMessage" | "missingErrorMessage", [(import("./rules/error-handling/error-message").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+        name: string;
+    };
+    'reliability/no-missing-null-checks': TSESLint.RuleModule<"missingNullCheck" | "useOptionalChaining" | "useNullishCoalescing" | "addExplicitCheck", [(import("./rules/reliability/no-missing-null-checks").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+        name: string;
+    };
+    'reliability/no-unsafe-type-narrowing': TSESLint.RuleModule<"unsafeTypeNarrowing" | "useTypeGuard" | "useProperNarrowing" | "validateBeforeAssert", [(import("./rules/reliability/no-unsafe-type-narrowing").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+        name: string;
+    };
+    'reliability/require-network-timeout': TSESLint.RuleModule<"violationDetected", [(import("./rules/reliability/require-network-timeout").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+        name: string;
+    };
+    'reliability/no-await-in-loop': TSESLint.RuleModule<"awaitInLoop" | "suggestPromiseAll" | "suggestConcurrent" | "considerSequential" | "asyncLoopPattern", [(import("./rules/reliability/no-await-in-loop").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+        name: string;
+    };
+};
+export declare const plugin: {
+    meta: {
+        name: string;
+        version: string;
+    };
+    rules: {
+        'no-unhandled-promise': TSESLint.RuleModule<"unhandledPromise" | "addCatch" | "useTryCatch" | "useAwait", [(import("./rules/error-handling/no-unhandled-promise").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+            name: string;
+        };
+        'no-silent-errors': TSESLint.RuleModule<"silentError" | "addErrorLogging" | "addErrorHandling" | "rethrowError", [(import("./rules/error-handling/no-silent-errors").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+            name: string;
+        };
+        'no-missing-error-context': TSESLint.RuleModule<"missingErrorContext" | "addErrorMessage" | "addErrorStack" | "useErrorClass", [(import("./rules/error-handling/no-missing-error-context").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+            name: string;
+        };
+        'error-message': TSESLint.RuleModule<"addErrorMessage" | "missingErrorMessage", [(import("./rules/error-handling/error-message").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+            name: string;
+        };
+        'no-missing-null-checks': TSESLint.RuleModule<"missingNullCheck" | "useOptionalChaining" | "useNullishCoalescing" | "addExplicitCheck", [(import("./rules/reliability/no-missing-null-checks").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+            name: string;
+        };
+        'no-unsafe-type-narrowing': TSESLint.RuleModule<"unsafeTypeNarrowing" | "useTypeGuard" | "useProperNarrowing" | "validateBeforeAssert", [(import("./rules/reliability/no-unsafe-type-narrowing").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+            name: string;
+        };
+        'require-network-timeout': TSESLint.RuleModule<"violationDetected", [(import("./rules/reliability/require-network-timeout").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+            name: string;
+        };
+        'no-await-in-loop': TSESLint.RuleModule<"awaitInLoop" | "suggestPromiseAll" | "suggestConcurrent" | "considerSequential" | "asyncLoopPattern", [(import("./rules/reliability/no-await-in-loop").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+            name: string;
+        };
+        'error-handling/no-unhandled-promise': TSESLint.RuleModule<"unhandledPromise" | "addCatch" | "useTryCatch" | "useAwait", [(import("./rules/error-handling/no-unhandled-promise").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+            name: string;
+        };
+        'error-handling/no-silent-errors': TSESLint.RuleModule<"silentError" | "addErrorLogging" | "addErrorHandling" | "rethrowError", [(import("./rules/error-handling/no-silent-errors").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+            name: string;
+        };
+        'error-handling/no-missing-error-context': TSESLint.RuleModule<"missingErrorContext" | "addErrorMessage" | "addErrorStack" | "useErrorClass", [(import("./rules/error-handling/no-missing-error-context").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+            name: string;
+        };
+        'error-handling/error-message': TSESLint.RuleModule<"addErrorMessage" | "missingErrorMessage", [(import("./rules/error-handling/error-message").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+            name: string;
+        };
+        'reliability/no-missing-null-checks': TSESLint.RuleModule<"missingNullCheck" | "useOptionalChaining" | "useNullishCoalescing" | "addExplicitCheck", [(import("./rules/reliability/no-missing-null-checks").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+            name: string;
+        };
+        'reliability/no-unsafe-type-narrowing': TSESLint.RuleModule<"unsafeTypeNarrowing" | "useTypeGuard" | "useProperNarrowing" | "validateBeforeAssert", [(import("./rules/reliability/no-unsafe-type-narrowing").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+            name: string;
+        };
+        'reliability/require-network-timeout': TSESLint.RuleModule<"violationDetected", [(import("./rules/reliability/require-network-timeout").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+            name: string;
+        };
+        'reliability/no-await-in-loop': TSESLint.RuleModule<"awaitInLoop" | "suggestPromiseAll" | "suggestConcurrent" | "considerSequential" | "asyncLoopPattern", [(import("./rules/reliability/no-await-in-loop").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+            name: string;
+        };
+    };
+};
+export declare const configs: {
+    recommended: {
+        plugins: {
+            '@interlace/reliability': {
+                meta: {
+                    name: string;
+                    version: string;
+                };
+                rules: {
+                    'no-unhandled-promise': TSESLint.RuleModule<"unhandledPromise" | "addCatch" | "useTryCatch" | "useAwait", [(import("./rules/error-handling/no-unhandled-promise").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+                        name: string;
+                    };
+                    'no-silent-errors': TSESLint.RuleModule<"silentError" | "addErrorLogging" | "addErrorHandling" | "rethrowError", [(import("./rules/error-handling/no-silent-errors").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+                        name: string;
+                    };
+                    'no-missing-error-context': TSESLint.RuleModule<"missingErrorContext" | "addErrorMessage" | "addErrorStack" | "useErrorClass", [(import("./rules/error-handling/no-missing-error-context").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+                        name: string;
+                    };
+                    'error-message': TSESLint.RuleModule<"addErrorMessage" | "missingErrorMessage", [(import("./rules/error-handling/error-message").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+                        name: string;
+                    };
+                    'no-missing-null-checks': TSESLint.RuleModule<"missingNullCheck" | "useOptionalChaining" | "useNullishCoalescing" | "addExplicitCheck", [(import("./rules/reliability/no-missing-null-checks").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+                        name: string;
+                    };
+                    'no-unsafe-type-narrowing': TSESLint.RuleModule<"unsafeTypeNarrowing" | "useTypeGuard" | "useProperNarrowing" | "validateBeforeAssert", [(import("./rules/reliability/no-unsafe-type-narrowing").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+                        name: string;
+                    };
+                    'require-network-timeout': TSESLint.RuleModule<"violationDetected", [(import("./rules/reliability/require-network-timeout").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+                        name: string;
+                    };
+                    'no-await-in-loop': TSESLint.RuleModule<"awaitInLoop" | "suggestPromiseAll" | "suggestConcurrent" | "considerSequential" | "asyncLoopPattern", [(import("./rules/reliability/no-await-in-loop").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+                        name: string;
+                    };
+                    'error-handling/no-unhandled-promise': TSESLint.RuleModule<"unhandledPromise" | "addCatch" | "useTryCatch" | "useAwait", [(import("./rules/error-handling/no-unhandled-promise").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+                        name: string;
+                    };
+                    'error-handling/no-silent-errors': TSESLint.RuleModule<"silentError" | "addErrorLogging" | "addErrorHandling" | "rethrowError", [(import("./rules/error-handling/no-silent-errors").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+                        name: string;
+                    };
+                    'error-handling/no-missing-error-context': TSESLint.RuleModule<"missingErrorContext" | "addErrorMessage" | "addErrorStack" | "useErrorClass", [(import("./rules/error-handling/no-missing-error-context").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+                        name: string;
+                    };
+                    'error-handling/error-message': TSESLint.RuleModule<"addErrorMessage" | "missingErrorMessage", [(import("./rules/error-handling/error-message").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+                        name: string;
+                    };
+                    'reliability/no-missing-null-checks': TSESLint.RuleModule<"missingNullCheck" | "useOptionalChaining" | "useNullishCoalescing" | "addExplicitCheck", [(import("./rules/reliability/no-missing-null-checks").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+                        name: string;
+                    };
+                    'reliability/no-unsafe-type-narrowing': TSESLint.RuleModule<"unsafeTypeNarrowing" | "useTypeGuard" | "useProperNarrowing" | "validateBeforeAssert", [(import("./rules/reliability/no-unsafe-type-narrowing").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+                        name: string;
+                    };
+                    'reliability/require-network-timeout': TSESLint.RuleModule<"violationDetected", [(import("./rules/reliability/require-network-timeout").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+                        name: string;
+                    };
+                    'reliability/no-await-in-loop': TSESLint.RuleModule<"awaitInLoop" | "suggestPromiseAll" | "suggestConcurrent" | "considerSequential" | "asyncLoopPattern", [(import("./rules/reliability/no-await-in-loop").Options | undefined)?], unknown, TSESLint.RuleListener> & {
+                        name: string;
+                    };
+                };
+            };
+        };
+        rules: {
+            '@interlace/reliability/error-handling/no-silent-errors': "warn";
+            '@interlace/reliability/reliability/no-missing-null-checks': "warn";
+            '@interlace/reliability/reliability/require-network-timeout': "error";
+        };
+    };
+};
+export default plugin;

package/src/index.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * Copyright (c) 2025 Ofri Peretz
+ * Licensed under the MIT License. Use of this source code is governed by the
+ * MIT license that can be found in the LICENSE file.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configs = exports.plugin = exports.rules = void 0;
+// Error handling rules
+const no_unhandled_promise_1 = require("./rules/error-handling/no-unhandled-promise");
+const no_silent_errors_1 = require("./rules/error-handling/no-silent-errors");
+const no_missing_error_context_1 = require("./rules/error-handling/no-missing-error-context");
+const error_message_1 = require("./rules/error-handling/error-message");
+// Reliability rules
+const no_missing_null_checks_1 = require("./rules/reliability/no-missing-null-checks");
+const no_unsafe_type_narrowing_1 = require("./rules/reliability/no-unsafe-type-narrowing");
+const require_network_timeout_1 = require("./rules/reliability/require-network-timeout");
+const no_await_in_loop_1 = require("./rules/reliability/no-await-in-loop");
+exports.rules = {
+    'no-unhandled-promise': no_unhandled_promise_1.noUnhandledPromise,
+    'no-silent-errors': no_silent_errors_1.noSilentErrors,
+    'no-missing-error-context': no_missing_error_context_1.noMissingErrorContext,
+    'error-message': error_message_1.errorMessage,
+    'no-missing-null-checks': no_missing_null_checks_1.noMissingNullChecks,
+    'no-unsafe-type-narrowing': no_unsafe_type_narrowing_1.noUnsafeTypeNarrowing,
+    'require-network-timeout': require_network_timeout_1.requireNetworkTimeout,
+    'no-await-in-loop': no_await_in_loop_1.noAwaitInLoop,
+    // Categorized names
+    'error-handling/no-unhandled-promise': no_unhandled_promise_1.noUnhandledPromise,
+    'error-handling/no-silent-errors': no_silent_errors_1.noSilentErrors,
+    'error-handling/no-missing-error-context': no_missing_error_context_1.noMissingErrorContext,
+    'error-handling/error-message': error_message_1.errorMessage,
+    'reliability/no-missing-null-checks': no_missing_null_checks_1.noMissingNullChecks,
+    'reliability/no-unsafe-type-narrowing': no_unsafe_type_narrowing_1.noUnsafeTypeNarrowing,
+    'reliability/require-network-timeout': require_network_timeout_1.requireNetworkTimeout,
+    'reliability/no-await-in-loop': no_await_in_loop_1.noAwaitInLoop,
+};
+exports.plugin = {
+    meta: {
+        name: 'eslint-plugin-reliability',
+        version: '1.0.0',
+    },
+    rules: exports.rules,
+};
+exports.configs = {
+    recommended: {
+        plugins: {
+            '@interlace/reliability': exports.plugin,
+        },
+        rules: {
+            '@interlace/reliability/error-handling/no-silent-errors': 'warn',
+            '@interlace/reliability/reliability/no-missing-null-checks': 'warn',
+            '@interlace/reliability/reliability/require-network-timeout': 'error',
+        },
+    },
+};
+exports.default = exports.plugin;

package/src/lib/eslint-plugin-reliability.d.ts

@@ -0,0 +1 @@
+export declare function eslintPluginReliability(): string;

package/src/lib/eslint-plugin-reliability.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eslintPluginReliability = eslintPluginReliability;
+function eslintPluginReliability() {
+    return 'eslint-plugin-reliability';
+}

package/src/rules/error-handling/error-message.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2025 Ofri Peretz
+ * Licensed under the MIT License. Use of this source code is governed by the
+ * MIT license that can be found in the LICENSE file.
+ */
+/**
+ * ESLint Rule: error-message
+ * Enforces providing a message when creating built-in Error objects
+ */
+import type { TSESLint } from '@interlace/eslint-devkit';
+type MessageIds = 'missingErrorMessage' | 'addErrorMessage';
+export interface Options {
+    /** Allow Error() without message (not recommended) */
+    allowEmptyCatch?: boolean;
+}
+type RuleOptions = [Options?];
+export declare const errorMessage: TSESLint.RuleModule<MessageIds, RuleOptions, unknown, TSESLint.RuleListener> & {
+    name: string;
+};
+export {};

package/src/rules/error-handling/error-message.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * Copyright (c) 2025 Ofri Peretz
+ * Licensed under the MIT License. Use of this source code is governed by the
+ * MIT license that can be found in the LICENSE file.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorMessage = void 0;
+const eslint_devkit_1 = require("@interlace/eslint-devkit");
+const eslint_devkit_2 = require("@interlace/eslint-devkit");
+exports.errorMessage = (0, eslint_devkit_1.createRule)({
+    name: 'error-message',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce providing a message when creating built-in Error objects for better debugging',
+        },
+        hasSuggestions: true,
+        messages: {
+            missingErrorMessage: (0, eslint_devkit_2.formatLLMMessage)({
+                icon: eslint_devkit_2.MessageIcons.INFO,
+                issueName: 'Missing Error Message',
+                description: 'Error constructor called without message parameter',
+                severity: 'HIGH',
+                fix: 'Add descriptive error message: new Error("description")',
+                documentationLink: 'https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/error-message.md',
+            }),
+            addErrorMessage: (0, eslint_devkit_2.formatLLMMessage)({
+                icon: eslint_devkit_2.MessageIcons.WARNING,
+                issueName: 'Add Error Message',
+                description: 'Add descriptive error message to constructor',
+                severity: 'HIGH',
+                fix: 'Add descriptive error message: new Error("description")',
+                documentationLink: 'https://github.com/sindresorhus/eslint-plugin-unicorn/blob/main/docs/rules/error-message.md',
+            }),
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allowEmptyCatch: {
+                        type: 'boolean',
+                        default: false,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [{ allowEmptyCatch: false }],
+    create(context) {
+        const [options] = context.options;
+        const { allowEmptyCatch = false } = options || {};
+        // Built-in Error constructors that should have messages
+        const errorConstructors = new Set([
+            'Error',
+            'TypeError',
+            'ReferenceError',
+            'SyntaxError',
+            'RangeError',
+            'EvalError',
+            'URIError',
+        ]);
+        function isErrorConstructor(name) {
+            return errorConstructors.has(name);
+        }
+        function hasMessageArgument(node) {
+            // Check if there are arguments
+            if (!node.arguments || node.arguments.length === 0) {
+                return false;
+            }
+            // Check if first argument is a non-empty string or expression
+            const firstArg = node.arguments[0];
+            if (firstArg.type === 'Literal') {
+                // Allow non-empty strings
+                return (typeof firstArg.value === 'string' && firstArg.value.trim().length > 0);
+            }
+            // Allow any expression (variable, function call, etc.) as it might be dynamic
+            return true;
+        }
+        function isInCatchClause(node) {
+            let current = node;
+            while (current) {
+                if (current.type === 'CatchClause') {
+                    return true;
+                }
+                current = current.parent;
+            }
+            return false;
+        }
+        function checkErrorCreation(node) {
+            let constructorName = null;
+            if (node.type === 'NewExpression') {
+                // new Error(...)
+                if (node.callee.type === 'Identifier') {
+                    constructorName = node.callee.name;
+                }
+            }
+            else if (node.type === 'CallExpression') {
+                // Error(...) - function call style
+                if (node.callee.type === 'Identifier') {
+                    constructorName = node.callee.name;
+                }
+            }
+            if (!constructorName || !isErrorConstructor(constructorName)) {
+                return;
+            }
+            // Allow empty catch if option is enabled
+            if (allowEmptyCatch && isInCatchClause(node)) {
+                return;
+            }
+            // Check if message is provided
+            if (!hasMessageArgument(node)) {
+                context.report({
+                    node,
+                    messageId: 'missingErrorMessage',
+                    data: {
+                        constructor: constructorName,
+                    },
+                    suggest: [
+                        {
+                            messageId: 'addErrorMessage',
+                            data: { constructor: constructorName },
+                            fix(fixer) {
+                                if (node.arguments.length === 0) {
+                                    // No arguments: replace the empty parentheses with ("Error message")
+                                    const parenStart = node.callee.range[1];
+                                    const parenEnd = node.range[1];
+                                    return fixer.replaceTextRange([parenStart, parenEnd], '("Error message")');
+                                }
+                                else {
+                                    // Has arguments: replace the first argument with "Error message"
+                                    return fixer.replaceText(node.arguments[0], '"Error message"');
+                                }
+                            },
+                        },
+                    ],
+                });
+            }
+        }
+        return {
+            NewExpression: checkErrorCreation,
+            CallExpression: checkErrorCreation,
+        };
+    },
+});