@opensip-cli/checks-universal 0.1.0

package/dist/checks/quality/patterns/performance-anti-patterns.js

@@ -0,0 +1,239 @@
+// @fitness-ignore-file no-unbounded-concurrency -- Concurrency bounded by design in this context
+// @fitness-ignore-file performance-anti-patterns -- this file IS the performance-anti-patterns check; loop body iterates the PATTERNS array (small, constant) and "await" appears in surrounding comments describing what the check detects
+/**
+ * @fileoverview Performance Anti-Patterns Check
+ *
+ * Detects common performance anti-patterns:
+ * - Sequential awaits in loops
+ * - Spread operators in loops
+ * - String concatenation in loops
+ * - Nested O(n^2) loops
+ */
+import { defineCheck, isTestFile } from '@opensip-cli/fitness';
+// Anti-pattern type identifiers
+const ANTI_PATTERN_TYPES = {
+    SEQUENTIAL_AWAIT: 'sequential-await',
+    SPREAD_IN_LOOP: 'spread-in-loop',
+    STRING_CONCAT_IN_LOOP: 'string-concat-in-loop',
+};
+// Patterns use bounded quantifiers to prevent ReDoS vulnerabilities
+const PATTERNS = [
+    {
+        // Bounded to prevent super-linear runtime
+        pattern: /for\s{0,5}\([^)]{0,200}\)\s{0,5}\{[^}]{0,500}await\s/,
+        type: ANTI_PATTERN_TYPES.SEQUENTIAL_AWAIT,
+        message: 'Sequential await in for loop - consider Promise.all()',
+        severity: 'warning',
+    },
+    {
+        // Bounded to prevent super-linear runtime
+        pattern: /while\s{0,5}\([^)]{0,200}\)\s{0,5}\{[^}]{0,500}await\s/,
+        type: ANTI_PATTERN_TYPES.SEQUENTIAL_AWAIT,
+        message: 'Sequential await in while loop - consider Promise.all()',
+        severity: 'warning',
+    },
+    {
+        // Bounded to prevent super-linear runtime
+        pattern: /\.forEach\([^)]{0,200}\)\s{0,5}\{[^}]{0,500}await\s/,
+        type: ANTI_PATTERN_TYPES.SEQUENTIAL_AWAIT,
+        message: 'Sequential await in forEach - use for...of with Promise.all()',
+        severity: 'warning',
+    },
+    {
+        // Coarse context gate: a `for` body that contains *some* `[`/`{`-prefixed
+        // spread. This only decides whether the line is worth inspecting; the
+        // precise accumulation-vs-copy decision is made per-line by
+        // isAccumulatingSpread (which ignores defensive copies and call-args).
+        // Bounded to prevent super-linear runtime.
+        pattern: /for\s{0,5}\([^)]{0,200}\)\s{0,5}\{[^}]{0,500}[[{]\s{0,5}\.\.\./,
+        type: ANTI_PATTERN_TYPES.SPREAD_IN_LOOP,
+        message: 'Spread-accumulation in a loop — rebuilding a collection by spreading it back into itself is O(n^2); push/assign into the existing collection instead',
+        severity: 'warning',
+    },
+    {
+        // Bounded to prevent super-linear runtime
+        pattern: /for\s{0,5}\([^)]{0,200}\)\s{0,5}\{[^}]{0,500}\+=\s{0,5}['"`]/,
+        type: ANTI_PATTERN_TYPES.STRING_CONCAT_IN_LOOP,
+        message: 'String concatenation in loop - use array.join() instead',
+        severity: 'warning',
+    },
+];
+/**
+ * Recognize retry/backoff loops, where sequential `await` is the entire
+ * point — running attempts in parallel would defeat retry semantics. The
+ * giveaway is an `await delay(`, `await sleep(`, `await setTimeout`, or
+ * `await wait(` inside the same loop body. These loops are bounded by
+ * their retry counter, not by data volume, so the sequential-await
+ * suggestion is a false positive.
+ *
+ * Bounded quantifiers prevent ReDoS — context is at most 8 lines.
+ */
+const RETRY_LOOP_BODY = /await\s{1,5}(delay|sleep|wait|setTimeout|backoff|pause)\s{0,5}\(/;
+/* v8 ignore start -- multi-pattern AST-style detector with many type-specific branches; covered indirectly */
+function checkLineForPerformancePatterns(options) {
+    const { lines, index } = options;
+    const line = lines[index];
+    if (!line)
+        return null;
+    // Get multi-line context for loop detection
+    const contextStart = Math.max(0, index - 2);
+    const contextEnd = Math.min(lines.length, index + 5);
+    const context = lines.slice(contextStart, contextEnd).join('\n');
+    // Wider window for retry-loop detection — the `await delay()` that
+    // marks an intentional retry/backoff loop often sits past the small
+    // 8-line context window that the anti-pattern regexes themselves use.
+    // 30 lines forward covers nearly all real retry helpers without
+    // crossing function boundaries in normal code.
+    const retryContextEnd = Math.min(lines.length, index + 30);
+    const retryContext = lines.slice(contextStart, retryContextEnd).join('\n');
+    for (const patternConfig of PATTERNS) {
+        if (patternConfig.pattern.test(context)) {
+            // Skip retry/backoff loops — sequential awaits with intentional
+            // pacing between attempts. Only applies to the sequential-await
+            // pattern (a spread or string-concat in a retry loop is still a
+            // real bug).
+            if (patternConfig.type === ANTI_PATTERN_TYPES.SEQUENTIAL_AWAIT &&
+                RETRY_LOOP_BODY.test(retryContext)) {
+                continue;
+            }
+            // Check if this line contains the key indicator
+            // Using bounded quantifiers to prevent ReDoS
+            const isSequentialAwait = patternConfig.type === ANTI_PATTERN_TYPES.SEQUENTIAL_AWAIT && line.includes('await');
+            const isSpreadInLoop = patternConfig.type === ANTI_PATTERN_TYPES.SPREAD_IN_LOOP && isAccumulatingSpread(line);
+            const isStringConcatInLoop = patternConfig.type === ANTI_PATTERN_TYPES.STRING_CONCAT_IN_LOOP &&
+                /\+=\s{0,5}['"`]/.test(line);
+            const isRelevantLine = isSequentialAwait || isSpreadInLoop || isStringConcatInLoop;
+            if (isRelevantLine) {
+                const lineNum = index + 1;
+                const suggestion = getPerformanceSuggestion(patternConfig.type, patternConfig.message);
+                return {
+                    line: lineNum,
+                    column: 0,
+                    message: patternConfig.message,
+                    severity: patternConfig.severity,
+                    suggestion,
+                    match: line,
+                };
+            }
+        }
+    }
+    return null;
+}
+/* v8 ignore stop */
+/**
+ * Detect spread-*accumulation* in a loop — the only spread shape that is
+ * actually O(n²). The smell is re-reading a collection and spreading it
+ * back into a new literal that replaces it, so each iteration copies the
+ * whole accumulated collection to append a few elements:
+ *
+ *   acc = [...acc, x]                 // self-referential array rebuild
+ *   state = { ...state, k: v }        // self-referential object rebuild
+ *   m.set(k, [...m.get(k), x])        // grouping into a Map slot
+ *   obj[k] = [...obj[k], x]           // grouping into an indexed slot
+ *
+ * Spreads that are NOT accumulation are intentionally ignored, because
+ * flagging them produced false positives (and collided with eslint's
+ * `unicorn/prefer-spread`, which prefers `[...x]` over `x.slice()`):
+ *
+ *   const sorted = [...arr].sort()    // one-time defensive copy, O(n)
+ *   fn(...args)                       // spread call-arguments
+ *   const merged = [...a, ...b]       // one-time merge (LHS ≠ either source)
+ *   const { id, ...rest } = row       // rest-destructuring
+ *
+ * Limitation: a copy split across two statements
+ * (`const t = [...acc, x]; acc = t`) is not recognized — detecting that
+ * needs data flow, which this line-oriented check does not do. We prefer
+ * missing those rare cases over emitting false positives on every
+ * defensive copy. All quantifiers are bounded to prevent ReDoS.
+ */
+function isAccumulatingSpread(line) {
+    if (!line.includes('...'))
+        return false;
+    // Self-referential rebuild: `ID = [...ID` / `ID = {...ID` (spread re-reads
+    // the same binding being assigned). The `[^=;]` window allows leading
+    // elements like `x = [first, ...x]`.
+    if (/\b([A-Za-z_$][\w$]*)\s{0,5}=\s{0,5}[[{][^=;]{0,200}\.\.\.\s{0,5}\1\b/.test(line))
+        return true;
+    // Grouping into a Map slot: `X.set(k, [...X.get(...` (read-modify-write).
+    if (/\.set\s{0,5}\([^,;]{0,80},\s{0,5}[[{][^=;]{0,160}\.\.\.[^;]{0,80}\.get\s{0,5}\(/.test(line))
+        return true;
+    // Grouping into an indexed slot: `ID[k] = [...ID[`.
+    if (/\b([A-Za-z_$][\w$]*)\[[^\]]{0,80}\]\s{0,5}=\s{0,5}[[{][^=;]{0,160}\.\.\.\s{0,5}\1\b\[/.test(line))
+        return true;
+    return false;
+}
+/* v8 ignore start -- switch over anti-pattern types; covered when patterns fire */
+function getPerformanceSuggestion(type, defaultMessage) {
+    switch (type) {
+        case 'sequential-await': {
+            return 'Collect promises in an array and use Promise.all() to execute them in parallel, e.g.: const results = await Promise.all(items.map(item => fetchItem(item)));';
+        }
+        case 'spread-in-loop': {
+            return 'Mutate the existing collection instead of rebuilding it each iteration: array.push(x) (or push(...items)), map.get(k).push(x), or Object.assign(obj, { k: v }) — spreading the accumulator back into a new literal is O(n^2)';
+        }
+        case 'string-concat-in-loop': {
+            return 'Collect strings in an array and call .join("") after the loop completes to avoid O(n^2) string allocation';
+        }
+        default: {
+            return defaultMessage;
+        }
+    }
+}
+/* v8 ignore stop */
+/**
+ * Check: quality/performance-anti-patterns
+ *
+ * Detects common performance anti-patterns in code.
+ */
+export const performanceAntiPatterns = defineCheck({
+    id: '7631876c-1688-4f36-b6c9-0b987202d9f9',
+    slug: 'performance-anti-patterns',
+    scope: { languages: ['typescript'], concerns: ['backend', 'server'] },
+    contentFilter: 'strip-strings',
+    confidence: 'medium',
+    description: 'Detects common performance anti-patterns (sequential await, spread in loops)',
+    longDescription: `**Purpose:** Detects common performance anti-patterns that cause unnecessary latency or O(n^2) complexity in production code.
+
+**Detects:** Analyzes each file individually. Uses regex patterns with multi-line context to find:
+- \`await\` inside \`for\`, \`while\`, or \`.forEach\` loops (sequential async operations)
+- Spread-*accumulation* inside \`for\` loops — rebuilding a collection by spreading it back into itself (\`acc = [...acc, x]\`, \`m.set(k, [...m.get(k), x])\`), which is O(n^2). One-time defensive copies (\`[...arr].sort()\`), spread call-arguments (\`fn(...args)\`), and merges (\`[...a, ...b]\`) are NOT flagged.
+- String concatenation (\`+= '...'\`) inside \`for\` loops (O(n^2) string allocation)
+
+**Why it matters:** These patterns cause quadratic performance degradation that is invisible at small scale but catastrophic with production data volumes.
+
+**Scope:** General best practice`,
+    tags: ['performance', 'quality'],
+    fileTypes: ['ts', 'tsx'],
+    // @fitness-ignore-next-line no-hardcoded-timeouts -- framework default for fitness check execution
+    timeout: 180_000, // 3 minutes - parses AST for all production files
+    analyze(content, filePath) {
+        // Skip test files — performance anti-patterns in tests are low-risk
+        if (isTestFile(filePath))
+            return [];
+        // Skip fitness check definitions — they iterate files with sequential async operations
+        // as part of analysis, which is bounded by the check's file set
+        if (filePath.includes('/fitness/src/checks/'))
+            return [];
+        // Skip diagnostic/debug endpoints — sequential processing is acceptable for diagnostics
+        if (filePath.includes('/diagnostics'))
+            return [];
+        // @lazy-ok -- 'await' appears as a string literal, not an actual await expression
+        // Quick filter: skip files without performance-related patterns
+        if (!content.includes('await') && !content.includes('for') && !content.includes('while')) {
+            return [];
+        }
+        // Skip files with explicit sequential-ok marker (intentional sequential processing)
+        if (content.includes('@sequential-ok'))
+            return [];
+        const violations = [];
+        const lines = content.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const violation = checkLineForPerformancePatterns({ lines, index: i });
+            if (violation) {
+                violations.push(violation);
+            }
+        }
+        return violations;
+    },
+});
+//# sourceMappingURL=performance-anti-patterns.js.map

package/dist/checks/quality/patterns/performance-anti-patterns.js.map

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

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

@@ -0,0 +1,27 @@
+/**
+ * @fileoverview Shared helpers for configuration validation checks
+ */
+/**
+ * Check if a character is a digit (0-9).
+ */
+export declare function isDigit(char: string | undefined): boolean;
+/**
+ * Check if a character is alphanumeric (0-9, A-Z, a-z).
+ */
+export declare function isAlphanumericChar(char: string | undefined): boolean;
+/**
+ * Skip whitespace in a string from a given position.
+ * @param str - The string to scan
+ * @param startPos - The starting position in the string
+ * @returns The position of the first non-whitespace character
+ */
+export declare function skipWhitespace(str: string, startPos: number): number;
+/**
+ * Parse digits from a string starting at a given position.
+ */
+export declare function parseDigits(str: string, startPos: number): {
+    endPos: number;
+    value: number;
+    digitCount: number;
+};
+//# sourceMappingURL=config-validation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config-validation.d.ts","sourceRoot":"","sources":["../../../../src/checks/resilience/_helpers/config-validation.ts"],"names":[],"mappings":"AAEA;;GAEG;AAQH;;GAEG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAIzD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAOpE;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAMpE;AAED;;GAEG;AACH,wBAAgB,WAAW,CACzB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,GACf;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAavD"}

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

@@ -0,0 +1,61 @@
+// @fitness-ignore-file fitness-check-architecture -- Helper module providing shared validation utilities; not a standalone check requiring defineCheck pattern
+// @fitness-ignore-file unused-config-options -- Config options reserved for future use or environment-specific
+/**
+ * @fileoverview Shared helpers for configuration validation checks
+ */
+import { logger } from '@opensip-cli/core';
+// =============================================================================
+// CHARACTER HELPERS
+// =============================================================================
+/**
+ * Check if a character is a digit (0-9).
+ */
+export function isDigit(char) {
+    if (!char)
+        return false;
+    const code = char.codePointAt(0) ?? 0;
+    return code >= 48 && code <= 57;
+}
+/**
+ * Check if a character is alphanumeric (0-9, A-Z, a-z).
+ */
+export function isAlphanumericChar(char) {
+    if (!char)
+        return false;
+    const code = char.codePointAt(0) ?? 0;
+    const isDigitChar = code >= 48 && code <= 57; // 0-9
+    const isUpperCase = code >= 65 && code <= 90; // A-Z
+    const isLowerCase = code >= 97 && code <= 122; // a-z
+    return isDigitChar || isUpperCase || isLowerCase;
+}
+/**
+ * Skip whitespace in a string from a given position.
+ * @param str - The string to scan
+ * @param startPos - The starting position in the string
+ * @returns The position of the first non-whitespace character
+ */
+export function skipWhitespace(str, startPos) {
+    let i = startPos;
+    while (i < str.length && (str[i] === ' ' || str[i] === '\t')) {
+        i++;
+    }
+    return i;
+}
+/**
+ * Parse digits from a string starting at a given position.
+ */
+export function parseDigits(str, startPos) {
+    logger.debug({
+        evt: 'fitness.checks.config_validation_helpers.parse_digits',
+        msg: 'Parsing digit sequence from string at given position',
+    });
+    let i = startPos;
+    while (i < str.length && isDigit(str[i])) {
+        i++;
+    }
+    const digitCount = i - startPos;
+    // @fitness-ignore-next-line numeric-validation -- substring is guaranteed digit-only by isDigit loop above
+    const value = digitCount > 0 ? Number.parseInt(str.slice(startPos, i), 10) : 0;
+    return { endPos: i, value, digitCount };
+}
+//# sourceMappingURL=config-validation.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config-validation.js","sourceRoot":"","sources":["../../../../src/checks/resilience/_helpers/config-validation.ts"],"names":[],"mappings":"AAAA,+JAA+J;AAC/J,+GAA+G;AAC/G;;GAEG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE3C,gFAAgF;AAChF,oBAAoB;AACpB,gFAAgF;AAEhF;;GAEG;AACH,MAAM,UAAU,OAAO,CAAC,IAAwB;IAC9C,IAAI,CAAC,IAAI;QAAE,OAAO,KAAK,CAAC;IACxB,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IACtC,OAAO,IAAI,IAAI,EAAE,IAAI,IAAI,IAAI,EAAE,CAAC;AAClC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAAwB;IACzD,IAAI,CAAC,IAAI;QAAE,OAAO,KAAK,CAAC;IACxB,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IACtC,MAAM,WAAW,GAAG,IAAI,IAAI,EAAE,IAAI,IAAI,IAAI,EAAE,CAAC,CAAC,MAAM;IACpD,MAAM,WAAW,GAAG,IAAI,IAAI,EAAE,IAAI,IAAI,IAAI,EAAE,CAAC,CAAC,MAAM;IACpD,MAAM,WAAW,GAAG,IAAI,IAAI,EAAE,IAAI,IAAI,IAAI,GAAG,CAAC,CAAC,MAAM;IACrD,OAAO,WAAW,IAAI,WAAW,IAAI,WAAW,CAAC;AACnD,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,GAAW,EAAE,QAAgB;IAC1D,IAAI,CAAC,GAAG,QAAQ,CAAC;IACjB,OAAO,CAAC,GAAG,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,EAAE,CAAC;QAC7D,CAAC,EAAE,CAAC;IACN,CAAC;IACD,OAAO,CAAC,CAAC;AACX,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,WAAW,CACzB,GAAW,EACX,QAAgB;IAEhB,MAAM,CAAC,KAAK,CAAC;QACX,GAAG,EAAE,uDAAuD;QAC5D,GAAG,EAAE,sDAAsD;KAC5D,CAAC,CAAC;IACH,IAAI,CAAC,GAAG,QAAQ,CAAC;IACjB,OAAO,CAAC,GAAG,GAAG,CAAC,MAAM,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QACzC,CAAC,EAAE,CAAC;IACN,CAAC;IACD,MAAM,UAAU,GAAG,CAAC,GAAG,QAAQ,CAAC;IAChC,2GAA2G;IAC3G,MAAM,KAAK,GAAG,UAAU,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC/E,OAAO,EAAE,MAAM,EAAE,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC;AAC1C,CAAC"}

package/dist/checks/resilience/batch-operations.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @fileoverview Batch operations and memory resilience checks
+ */
+/**
+ * Check: resilience/batch-operation-limits
+ *
+ * Detects batch operations that may process unbounded data:
+ * - Array operations on potentially large datasets without pagination
+ * - Async operations without concurrency limits
+ * - Database queries without LIMIT clauses
+ */
+export declare const batchOperationLimits: import("@opensip-cli/fitness").Check;
+/**
+ * Check: resilience/unbounded-memory
+ *
+ * Detects potential memory leaks and OOM risks:
+ * - Maps/Sets/Arrays in classes without eviction logic
+ * - File reads without prior size checks
+ * - Growing buffers without backpressure
+ */
+export declare const unboundedMemory: import("@opensip-cli/fitness").Check;
+//# sourceMappingURL=batch-operations.d.ts.map

package/dist/checks/resilience/batch-operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-operations.d.ts","sourceRoot":"","sources":["../../../src/checks/resilience/batch-operations.ts"],"names":[],"mappings":"AAEA;;GAEG;AAqGH;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,sCAiF/B,CAAC;AAuLH;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,sCAyG1B,CAAC"}