@opensip-cli/checks-universal 0.1.0

package/dist/checks/resilience/recovery-patterns.js

@@ -0,0 +1,273 @@
+// @fitness-ignore-file recovery-patterns -- Check definition contains custom timeout pattern strings it detects
+/**
+ * @fileoverview Enforce use of canonical recovery patterns
+ */
+import { logger } from '@opensip-cli/core';
+import { defineCheck, isCommentLine } from '@opensip-cli/fitness';
+// Recovery patterns
+const RECOVERY_PATTERNS = [
+    {
+        id: 'manual-retry-loop',
+        // Pattern: for (let retry... or for (let numRetry...
+        regex: /for\s{0,10}\(\s{0,10}let\s{1,10}\w{0,30}[Rr]etry/g,
+        message: 'Manual retry loop detected',
+        suggestion: 'Use a shared recovery/retry utility with standardized backoff and jitter instead of manual retry loops',
+        severity: 'error',
+        skipInComments: true,
+    },
+    {
+        id: 'manual-retry-while',
+        // Pattern: while (x < retries) or while (x < maxRetries)
+        regex: /while\s{0,10}\(\s{0,10}\w{1,30}\s{0,10}<\s{0,10}(?:max)?[Rr]etries?\s{0,10}\)/g,
+        message: 'Manual retry while-loop detected',
+        suggestion: 'Use a shared recovery/retry utility with standardized backoff and jitter instead of manual retry loops',
+        severity: 'error',
+        skipInComments: true,
+    },
+    {
+        id: 'custom-circuit-breaker',
+        // Pattern: circuitState = or isOpen: or consecutiveFailures =
+        regex: /(?:circuitState|isOpen|consecutiveFailures)\s{0,10}[=:]/g,
+        message: 'Custom circuit breaker state detected',
+        suggestion: 'Use a shared recovery/retry utility with circuit breaker support instead of custom circuit breaker state',
+        severity: 'error',
+        skipInComments: true,
+    },
+    {
+        id: 'custom-timeout',
+        // Pattern: new Promise((resolve, reject) => { ... setTimeout ... reject
+        regex: /new\s{1,10}Promise\s{0,10}\(\s{0,10}\(resolve,\s{0,10}reject\)\s{0,10}=>\s{0,10}\{[\s\S]{0,500}?setTimeout[\s\S]{0,500}?reject/g,
+        message: 'Custom timeout wrapper detected',
+        suggestion: 'Use a shared timeout utility instead of custom Promise-based timeout wrappers',
+        severity: 'warning',
+        skipInComments: true,
+        multiline: true,
+    },
+];
+// Cache patterns
+const CACHE_PATTERNS = [
+    {
+        id: 'custom-cache-map',
+        // Pattern: private cache = new Map or private readonly myCache: new Map
+        regex: /private\s{1,10}(?:readonly\s{1,10})?\w{0,30}[Cc]ache\s{0,10}[=:]\s{0,10}new\s{1,10}Map/g,
+        message: 'Custom Map-based cache detected',
+        suggestion: 'Use a shared cache abstraction with TTL management and eviction policies instead of custom Map-based caches',
+        severity: 'warning',
+        skipInComments: true,
+    },
+    {
+        id: 'custom-cache-object',
+        // Pattern: private cache = {} or private readonly myCache: {}
+        regex: /private\s{1,10}(?:readonly\s{1,10})?\w{0,30}[Cc]ache\s{0,10}[=:]\s{0,10}\{\s{0,10}\}/g,
+        message: 'Custom object-based cache detected',
+        suggestion: 'Use a shared cache abstraction with TTL management and eviction policies instead of custom object-based caches',
+        severity: 'warning',
+        skipInComments: true,
+    },
+];
+// Rate limiter patterns
+const RATE_LIMITER_PATTERNS = [
+    {
+        id: 'custom-rate-limiter',
+        regex: /(?:requestCount|rateLimitWindow|tokensRemaining)\s{0,10}[=:]/g,
+        message: 'Custom rate limiting detected',
+        suggestion: 'Use a shared rate limiter instead of custom rate limiting implementations',
+        severity: 'warning',
+        skipInComments: true,
+    },
+];
+// =============================================================================
+// HELPER FUNCTIONS
+// =============================================================================
+/** Check if file path matches exclusion pattern */
+function matchesExclusionPattern(filePath, patterns) {
+    logger.debug({
+        evt: 'fitness.checks.recovery_patterns.matches_exclusion_pattern',
+        msg: 'Checking if file path matches exclusion pattern',
+    });
+    for (const pattern of patterns) {
+        // Convert glob pattern to simple substring match for common cases
+        const normalizedPattern = pattern.replaceAll('**', '').replaceAll('*', '');
+        if (normalizedPattern && filePath.includes(normalizedPattern)) {
+            return true;
+        }
+    }
+    return false;
+}
+function createViolation(pattern, lineNumber, matchText) {
+    logger.debug({
+        evt: 'fitness.checks.recovery_patterns.create_violation',
+        msg: 'Creating violation record for detected pattern',
+    });
+    return {
+        line: lineNumber,
+        message: pattern.message,
+        severity: pattern.severity,
+        suggestion: pattern.suggestion,
+        match: matchText,
+        type: pattern.id,
+    };
+}
+function detectMultilinePattern(content, pattern) {
+    logger.debug({
+        evt: 'fitness.checks.recovery_patterns.detect_multiline_pattern',
+        msg: 'Detecting multiline pattern violations',
+    });
+    const violations = [];
+    pattern.regex.lastIndex = 0;
+    let match;
+    while ((match = pattern.regex.exec(content)) !== null) {
+        const lineNumber = content.slice(0, match.index).split('\n').length;
+        violations.push(createViolation(pattern, lineNumber, match[0].slice(0, 100)));
+    }
+    return violations;
+}
+function detectSingleLinePattern(lines, pattern) {
+    logger.debug({
+        evt: 'fitness.checks.recovery_patterns.detect_single_line_pattern',
+        msg: 'Detecting single line pattern violations',
+    });
+    const violations = [];
+    for (const [i, line] of lines.entries()) {
+        /* v8 ignore next -- defensive: lines.entries() never yields undefined */
+        if (line === undefined)
+            continue;
+        if (pattern.skipInComments && isCommentLine(line))
+            continue;
+        if (pattern.regex.global) {
+            pattern.regex.lastIndex = 0;
+        }
+        const match = pattern.regex.exec(line);
+        if (match) {
+            violations.push(createViolation(pattern, i + 1, match[0]));
+        }
+    }
+    return violations;
+}
+function detectPatternViolations(content, lines, pattern) {
+    logger.debug({
+        evt: 'fitness.checks.recovery_patterns.detect_pattern_violations',
+        msg: 'Detecting pattern violations for content',
+    });
+    if (pattern.regex.global) {
+        pattern.regex.lastIndex = 0;
+    }
+    if (pattern.multiline) {
+        return detectMultilinePattern(content, pattern);
+    }
+    return detectSingleLinePattern(lines, pattern);
+}
+function detectPatterns(content, filePath, patterns, excludePaths) {
+    logger.debug({
+        evt: 'fitness.checks.recovery_patterns.detect_patterns',
+        msg: 'Running pattern detection on file content',
+    });
+    if (matchesExclusionPattern(filePath, excludePaths)) {
+        return [];
+    }
+    const lines = content.split('\n');
+    const violations = [];
+    for (const pattern of patterns) {
+        const patternViolations = detectPatternViolations(content, lines, pattern);
+        for (const violation of patternViolations) {
+            violations.push(violation);
+        }
+    }
+    return violations;
+}
+// =============================================================================
+// CHECK DEFINITIONS
+// =============================================================================
+/**
+ * Check: resilience/recovery-patterns
+ *
+ * Ensures code uses a shared recovery/retry utility
+ * instead of custom retry loops, circuit breakers, or timeout wrappers.
+ */
+export const recoveryPatterns = defineCheck({
+    id: '64f07f7e-baed-4946-83be-2b8102a9f98b',
+    slug: 'recovery-patterns',
+    disabled: true,
+    scope: { languages: ['typescript'], concerns: ['backend', 'server'] },
+    contentFilter: 'strip-strings',
+    confidence: 'medium',
+    description: 'Enforce use of shared recovery/retry utilities instead of hand-rolled retry loops',
+    longDescription: `**Purpose:** Prevents hand-rolled retry loops, circuit breakers, and timeout wrappers in favor of the canonical recovery module.
+
+**Detects:**
+- Manual retry for-loops: \`for (let *retry\` or \`for (let *Retry\`
+- Manual retry while-loops: \`while (x < retries)\` or \`while (x < maxRetries)\`
+- Custom circuit breaker state: \`circuitState =\`, \`isOpen:\`, \`consecutiveFailures =\`
+- Custom timeout wrappers: \`new Promise((resolve, reject) => { ... setTimeout ... reject\` (multiline)
+- Skips comment lines when \`skipInComments\` is set
+
+**Why it matters:** Custom recovery logic duplicates proven patterns and lacks standardized backoff, jitter, and observability.
+
+**Scope:** Codebase-specific convention. Analyzes each file individually via regex.`,
+    tags: ['resilience', 'recovery', 'canonical'],
+    fileTypes: ['ts'],
+    analyze(content, filePath) {
+        return detectPatterns(content, filePath, RECOVERY_PATTERNS, [
+            'foundation/src/recovery',
+            '__tests__',
+        ]);
+    },
+});
+/**
+ * Check: resilience/no-custom-cache
+ *
+ * Ensures code uses a shared cache abstraction
+ * instead of custom Map-based caches.
+ */
+export const noCustomCache = defineCheck({
+    id: '4c389ae7-ea92-42ff-bcec-0eb9d5d69e3e',
+    slug: 'no-custom-cache',
+    disabled: true,
+    description: 'Enforce use of a shared cache abstraction instead of custom Map-based caches',
+    longDescription: `**Purpose:** Prevents custom Map- or object-based caches in favor of the canonical CacheClient from infrastructure.
+
+**Detects:**
+- \`private [readonly] *cache = new Map\` pattern (Map-based cache)
+- \`private [readonly] *cache = {}\` pattern (object-based cache)
+- Skips comment lines
+
+**Why it matters:** Custom caches lack TTL management, eviction policies, distributed invalidation, and observability that the canonical CacheClient provides.
+
+**Scope:** Codebase-specific convention. Analyzes each file individually via regex.`,
+    tags: ['resilience', 'canonical', 'cache'],
+    analyze(content, filePath) {
+        return detectPatterns(content, filePath, CACHE_PATTERNS, [
+            'infrastructure/src/cache',
+            '__tests__',
+        ]);
+    },
+});
+/**
+ * Check: resilience/no-custom-rate-limiter
+ *
+ * Ensures code uses a shared rate limiter
+ * instead of custom rate limiting implementations.
+ */
+export const noCustomRateLimiter = defineCheck({
+    id: '330407bb-d139-48f3-b51e-61516eb93929',
+    slug: 'no-custom-rate-limiter',
+    disabled: true,
+    description: 'Enforce use of a shared rate limiter instead of custom rate limiting implementations',
+    longDescription: `**Purpose:** Prevents custom rate limiting implementations in favor of the canonical RateLimiter from infrastructure.
+
+**Detects:**
+- Custom rate limiter state variables: \`requestCount =\`, \`rateLimitWindow =\`, \`tokensRemaining =\`
+- Skips comment lines
+
+**Why it matters:** Custom rate limiters lack distributed coordination, sliding window accuracy, and configuration consistency that the canonical module provides.
+
+**Scope:** Codebase-specific convention. Analyzes each file individually via regex.`,
+    tags: ['resilience', 'canonical', 'rate-limiting'],
+    analyze(content, filePath) {
+        return detectPatterns(content, filePath, RATE_LIMITER_PATTERNS, [
+            'infrastructure/src/rate-limiting',
+            '__tests__',
+        ]);
+    },
+});
+//# sourceMappingURL=recovery-patterns.js.map

package/dist/checks/resilience/recovery-patterns.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recovery-patterns.js","sourceRoot":"","sources":["../../../src/checks/resilience/recovery-patterns.ts"],"names":[],"mappings":"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"}

package/dist/checks/resilience/reentrancy-guard.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @fileoverview Detects boolean flag reentrancy guards that should use counters or mutexes
+ */
+/**
+ * Check: resilience/reentrancy-guard
+ *
+ * Detects module-scoped boolean flags used as reentrancy guards
+ * (e.g., `let serverRunning = false` with `if (serverRunning) return`).
+ * These are not re-entrant and can corrupt state with concurrent calls.
+ */
+export declare const reentrancyGuard: import("@opensip-cli/fitness").Check;
+//# sourceMappingURL=reentrancy-guard.d.ts.map

package/dist/checks/resilience/reentrancy-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reentrancy-guard.d.ts","sourceRoot":"","sources":["../../../src/checks/resilience/reentrancy-guard.ts"],"names":[],"mappings":"AAEA;;GAEG;AAmBH;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,sCAuE1B,CAAC"}

package/dist/checks/resilience/reentrancy-guard.js

@@ -0,0 +1,86 @@
+// @fitness-ignore-file project-readme-existence -- internal module, not a package root
+// @fitness-ignore-file fitness-check-coverage -- check implementation with framework-managed coverage
+/**
+ * @fileoverview Detects boolean flag reentrancy guards that should use counters or mutexes
+ */
+import { defineCheck, getLineNumber } from '@opensip-cli/fitness';
+/**
+ * Pattern for detecting module-scoped boolean state flags used as reentrancy guards.
+ * Matches: let serverRunning = false, let isRunning = false, etc.
+ */
+const BOOLEAN_FLAG_PATTERN = /^(?:let|var)\s+(\w+(?:Running|Started|Active|Initialized|Locked))\s*(?::\s*boolean\s*)?=\s*false/gm;
+/**
+ * Pattern for early return based on the flag (reentrancy guard)
+ */
+function createFlagCheckPattern(flagName) {
+    // @fitness-ignore-next-line semgrep-scan -- non-literal RegExp is intentional; flagName is extracted from regex match on source code identifiers (\w+), not user input
+    return new RegExp(String.raw `if\s*\(\s*${flagName}\s*\)\s*(?:return|\{)`);
+}
+/**
+ * Check: resilience/reentrancy-guard
+ *
+ * Detects module-scoped boolean flags used as reentrancy guards
+ * (e.g., `let serverRunning = false` with `if (serverRunning) return`).
+ * These are not re-entrant and can corrupt state with concurrent calls.
+ */
+export const reentrancyGuard = defineCheck({
+    id: 'd7f35c3b-af42-435f-b953-ee167060fecb',
+    slug: 'reentrancy-guard',
+    scope: { languages: ['typescript'], concerns: ['backend', 'frontend', 'cli'] },
+    contentFilter: 'strip-strings',
+    confidence: 'medium',
+    description: 'Detect boolean reentrancy guards that need counter/mutex semantics',
+    longDescription: `**Purpose:** Detects module-scoped boolean flags used as reentrancy guards that can fail under concurrent or nested calls.
+
+**Detects:**
+- Module-scoped \`let\` boolean variables with names like \`*Running\`, \`*Started\`, \`*Active\`, \`*Initialized\`, \`*Locked\` initialized to \`false\`
+- Paired with an \`if (flag) return\` guard pattern indicating reentrancy protection
+- These boolean guards are not re-entrant: nested calls will see the flag as \`true\` and silently skip, and concurrent calls can interleave flag reads/writes
+
+**Why it matters:** Boolean flags for reentrancy create race conditions where concurrent callers skip initialization or corrupt shared state. A reference counter or mutex provides correct semantics.
+
+**Scope:** General best practice. Analyzes each file individually via regex.`,
+    tags: ['resilience', 'concurrency', 'reentrancy'],
+    fileTypes: ['ts'],
+    analyze(content, filePath) {
+        const violations = [];
+        // Skip test files
+        if (filePath.includes('.test.') ||
+            filePath.includes('.spec.') ||
+            filePath.includes('__tests__')) {
+            return violations;
+        }
+        // Quick check
+        if (!content.includes('Running') &&
+            !content.includes('Started') &&
+            !content.includes('Active') &&
+            !content.includes('Initialized') &&
+            !content.includes('Locked')) {
+            return violations;
+        }
+        BOOLEAN_FLAG_PATTERN.lastIndex = 0;
+        let match;
+        while ((match = BOOLEAN_FLAG_PATTERN.exec(content)) !== null) {
+            const flagName = match[1];
+            if (!flagName)
+                continue;
+            // Check if there's a corresponding guard pattern
+            const guardPattern = createFlagCheckPattern(flagName);
+            if (!guardPattern.test(content))
+                continue;
+            const lineNumber = getLineNumber(content, match.index);
+            violations.push({
+                line: lineNumber,
+                column: 0,
+                message: `Boolean reentrancy guard '${flagName}' is not safe for concurrent or nested calls`,
+                severity: 'warning',
+                suggestion: 'Replace the boolean flag with a reference counter (increment on enter, decrement on exit) or use a mutex/semaphore for proper reentrancy protection.',
+                match: match[0],
+                type: 'boolean-reentrancy-guard',
+                filePath,
+            });
+        }
+        return violations;
+    },
+});
+//# sourceMappingURL=reentrancy-guard.js.map

package/dist/checks/resilience/reentrancy-guard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reentrancy-guard.js","sourceRoot":"","sources":["../../../src/checks/resilience/reentrancy-guard.ts"],"names":[],"mappings":"AAAA,uFAAuF;AACvF,sGAAsG;AACtG;;GAEG;AAEH,OAAO,EAAE,WAAW,EAAuB,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAEvF;;;GAGG;AACH,MAAM,oBAAoB,GACxB,oGAAoG,CAAC;AAEvG;;GAEG;AACH,SAAS,sBAAsB,CAAC,QAAgB;IAC9C,uKAAuK;IACvK,OAAO,IAAI,MAAM,CAAC,MAAM,CAAC,GAAG,CAAA,aAAa,QAAQ,uBAAuB,CAAC,CAAC;AAC5E,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,WAAW,CAAC;IACzC,EAAE,EAAE,sCAAsC;IAC1C,IAAI,EAAE,kBAAkB;IACxB,KAAK,EAAE,EAAE,SAAS,EAAE,CAAC,YAAY,CAAC,EAAE,QAAQ,EAAE,CAAC,SAAS,EAAE,UAAU,EAAE,KAAK,CAAC,EAAE;IAC9E,aAAa,EAAE,eAAe;IAE9B,UAAU,EAAE,QAAQ;IACpB,WAAW,EAAE,oEAAoE;IACjF,eAAe,EAAE;;;;;;;;;6EAS0D;IAC3E,IAAI,EAAE,CAAC,YAAY,EAAE,aAAa,EAAE,YAAY,CAAC;IACjD,SAAS,EAAE,CAAC,IAAI,CAAC;IAEjB,OAAO,CAAC,OAAe,EAAE,QAAgB;QACvC,MAAM,UAAU,GAAqB,EAAE,CAAC;QAExC,kBAAkB;QAClB,IACE,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC;YAC3B,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC;YAC3B,QAAQ,CAAC,QAAQ,CAAC,WAAW,CAAC,EAC9B,CAAC;YACD,OAAO,UAAU,CAAC;QACpB,CAAC;QAED,cAAc;QACd,IACE,CAAC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC;YAC5B,CAAC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC;YAC5B,CAAC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC;YAC3B,CAAC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC;YAChC,CAAC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAC3B,CAAC;YACD,OAAO,UAAU,CAAC;QACpB,CAAC;QAED,oBAAoB,CAAC,SAAS,GAAG,CAAC,CAAC;QACnC,IAAI,KAAK,CAAC;QACV,OAAO,CAAC,KAAK,GAAG,oBAAoB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC;YAC7D,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YAC1B,IAAI,CAAC,QAAQ;gBAAE,SAAS;YAExB,iDAAiD;YACjD,MAAM,YAAY,GAAG,sBAAsB,CAAC,QAAQ,CAAC,CAAC;YACtD,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC;gBAAE,SAAS;YAE1C,MAAM,UAAU,GAAG,aAAa,CAAC,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;YAEvD,UAAU,CAAC,IAAI,CAAC;gBACd,IAAI,EAAE,UAAU;gBAChB,MAAM,EAAE,CAAC;gBACT,OAAO,EAAE,6BAA6B,QAAQ,8CAA8C;gBAC5F,QAAQ,EAAE,SAAS;gBACnB,UAAU,EACR,sJAAsJ;gBACxJ,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;gBACf,IAAI,EAAE,0BAA0B;gBAChC,QAAQ;aACT,CAAC,CAAC;QACL,CAAC;QAED,OAAO,UAAU,CAAC;IACpB,CAAC;CACF,CAAC,CAAC"}

package/dist/checks/resilience/retry-config-validation.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @fileoverview Retry configuration validation check
+ */
+/**
+ * Check: resilience/retry-config-validation
+ *
+ * Validates retry configuration values to prevent:
+ * - Too many retries (resource exhaustion)
+ * - Too few retries (no fault tolerance)
+ * - Excessive backoff delays
+ */
+export declare const retryConfigValidation: import("@opensip-cli/fitness").Check;
+//# sourceMappingURL=retry-config-validation.d.ts.map

package/dist/checks/resilience/retry-config-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-config-validation.d.ts","sourceRoot":"","sources":["../../../src/checks/resilience/retry-config-validation.ts"],"names":[],"mappings":"AAAA;;GAEG;AA6IH;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,sCA+DhC,CAAC"}

package/dist/checks/resilience/retry-config-validation.js

@@ -0,0 +1,159 @@
+/**
+ * @fileoverview Retry configuration validation check
+ */
+import { logger } from '@opensip-cli/core';
+import { defineCheck } from '@opensip-cli/fitness';
+import { stripStringLiterals, stripStringsAndComments } from '@opensip-cli/fitness';
+import { isDigit } from './_helpers/config-validation.js';
+// =============================================================================
+// CONFIG PARSING
+// =============================================================================
+/**
+ * Parse a config value from a line using string matching.
+ */
+function parseConfigValueFromLine(line, configKey) {
+    logger.debug({
+        evt: 'fitness.checks.retry_config_validation.parse_config_value_from_line',
+        msg: 'Parsing config value from line',
+    });
+    const lowerLine = line.toLowerCase();
+    const lowerKey = configKey.toLowerCase();
+    const idx = lowerLine.indexOf(lowerKey);
+    if (idx === -1)
+        return null;
+    const afterKey = line.slice(Math.max(0, idx + configKey.length));
+    let i = 0;
+    // Skip whitespace
+    while (i < afterKey.length && (afterKey[i] === ' ' || afterKey[i] === '\t')) {
+        i++;
+    }
+    // Check for = or :
+    if (afterKey[i] !== '=' && afterKey[i] !== ':') {
+        return null;
+    }
+    i++;
+    // Skip whitespace
+    while (i < afterKey.length && (afterKey[i] === ' ' || afterKey[i] === '\t')) {
+        i++;
+    }
+    // Parse digits
+    const digitStart = i;
+    while (i < afterKey.length && isDigit(afterKey[i])) {
+        i++;
+    }
+    if (digitStart === i) {
+        return null; // No digits found
+    }
+    // @fitness-ignore-next-line numeric-validation -- substring is guaranteed digit-only by isDigit loop above
+    const value = Number.parseInt(afterKey.slice(digitStart, i), 10);
+    return {
+        value,
+        matchText: `${configKey}${afterKey.slice(0, Math.max(0, i))}`,
+    };
+}
+function checkMaxRetriesValue(value) {
+    logger.debug({
+        evt: 'fitness.checks.retry_config_validation.check_max_retries_value',
+        msg: 'Checking maxRetries value for excessive count',
+    });
+    if (value <= 10)
+        return null;
+    return {
+        message: `maxRetries of ${value} is excessive`,
+        severity: 'warning',
+        suggestion: 'Consider reducing maxRetries to 3-5 with exponential backoff. Use a shared retry utility for proper retry handling.',
+        type: 'excessive-retries',
+    };
+}
+function checkBaseDelayValue(value) {
+    logger.debug({
+        evt: 'fitness.checks.retry_config_validation.check_base_delay_value',
+        msg: 'Checking baseDelay value for aggressive timing',
+    });
+    if (value >= 100)
+        return null;
+    return {
+        message: `baseDelay of ${value}ms may be too aggressive`,
+        severity: 'warning',
+        suggestion: 'Consider a baseDelay of at least 100ms to avoid overwhelming downstream services. Use exponential backoff for better resilience.',
+        type: 'aggressive-retry-delay',
+    };
+}
+// =============================================================================
+// LINE CHECKING
+// =============================================================================
+function checkConfigOnLine(strippedLine, configKey, checker, lineNumber, filePath) {
+    const result = parseConfigValueFromLine(strippedLine, configKey);
+    if (!result)
+        return null;
+    const violation = checker(result.value);
+    if (!violation)
+        return null;
+    return {
+        line: lineNumber,
+        column: 0,
+        message: violation.message,
+        severity: violation.severity,
+        suggestion: violation.suggestion,
+        match: result.matchText,
+        type: violation.type,
+        filePath,
+    };
+}
+// =============================================================================
+// CHECK DEFINITION
+// =============================================================================
+/**
+ * Check: resilience/retry-config-validation
+ *
+ * Validates retry configuration values to prevent:
+ * - Too many retries (resource exhaustion)
+ * - Too few retries (no fault tolerance)
+ * - Excessive backoff delays
+ */
+export const retryConfigValidation = defineCheck({
+    id: '174659f8-56b5-4e8d-a495-3c3188fddaf8',
+    slug: 'retry-config-validation',
+    scope: { languages: ['typescript'], concerns: ['backend', 'server'] },
+    contentFilter: 'strip-strings',
+    confidence: 'medium',
+    description: 'Validate retry configs: flag excessive maxRetries (>10) and aggressive baseDelay (<100ms)',
+    longDescription: `**Purpose:** Validates retry configuration values to prevent resource exhaustion from too many retries or aggressive retry timing.
+
+**Detects:**
+- \`maxRetries = N\` or \`maxRetries: N\` where N > 10 (excessive retries)
+- \`baseDelay = N\` or \`baseDelay: N\` where N < 100ms (too aggressive)
+- Only scans files containing \`retry\` or \`attempt\` keywords
+
+**Why it matters:** Excessive retries can amplify failures into cascading outages; aggressive retry delays overwhelm already-struggling downstream services.
+
+**Scope:** General best practice. Analyzes each file individually via string parsing.`,
+    tags: ['resilience', 'retry', 'config'],
+    fileTypes: ['ts'],
+    analyze(content, filePath) {
+        const violations = [];
+        const strippedContent = stripStringsAndComments(content).toLowerCase();
+        if (!strippedContent.includes('retry') && !strippedContent.includes('attempt')) {
+            return violations;
+        }
+        const lines = content.split('\n');
+        for (const [i, line] of lines.entries()) {
+            if (!line)
+                continue;
+            const strippedLine = stripStringLiterals(line);
+            const trimmed = strippedLine.trim();
+            if (trimmed.startsWith('//') || trimmed.startsWith('*')) {
+                continue;
+            }
+            const lineNumber = i + 1;
+            const maxRetriesViolation = checkConfigOnLine(strippedLine, 'maxRetries', checkMaxRetriesValue, lineNumber, filePath);
+            if (maxRetriesViolation)
+                violations.push(maxRetriesViolation);
+            const baseDelayViolation = checkConfigOnLine(strippedLine, 'baseDelay', checkBaseDelayValue, lineNumber, filePath);
+            if (baseDelayViolation)
+                violations.push(baseDelayViolation);
+        }
+        return violations;
+    },
+});
+//# sourceMappingURL=retry-config-validation.js.map

package/dist/checks/resilience/retry-config-validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-config-validation.js","sourceRoot":"","sources":["../../../src/checks/resilience/retry-config-validation.ts"],"names":[],"mappings":"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"}

package/dist/checks/resilience/sentry/_helpers/sentry.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @fileoverview Shared helpers for Sentry fitness checks
+ * @module checks-builtin/checks/resilience/sentry/_helpers/sentry
+ */
+/**
+ * Quick bail-out: returns true if the file references Sentry at all.
+ * All Sentry checks should call this first to avoid unnecessary work.
+ */
+export declare function hasSentryUsage(content: string): boolean;
+/**
+ * Returns true if the file contains a `Sentry.init(` call.
+ * Used by checks that validate init configuration.
+ */
+export declare function hasSentryInit(content: string): boolean;
+/**
+ * Extracts the Sentry.init() call block from file content.
+ * Returns the line range (start/end indices) and the content of the init block.
+ * Handles multi-line init calls by tracking brace depth.
+ */
+export declare function extractSentryInitBlock(content: string): {
+    startLine: number;
+    endLine: number;
+    block: string;
+} | null;
+//# sourceMappingURL=sentry.d.ts.map

package/dist/checks/resilience/sentry/_helpers/sentry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sentry.d.ts","sourceRoot":"","sources":["../../../../../src/checks/resilience/sentry/_helpers/sentry.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;GAGG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED;;;;GAIG;AAEH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,GACd;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAgD9D"}