@opensip-cli/checks-typescript 0.1.10 → 0.1.12

package/dist/checks/quality/data-integrity/array-validation-detectors.js

@@ -0,0 +1,184 @@
+import * as ts from 'typescript';
+export const QUICK_FILTER_KEYWORDS = [
+    '[]',
+    'Array',
+    'array',
+    '.length',
+    '.push',
+    '.pop',
+    '.map(',
+    '.filter(',
+];
+const RELAXED_VALIDATION_PATHS = [
+    /\/internal\//,
+    /\/utils\//,
+    /\/helpers\//,
+    /\/cli\//,
+    /\/scripts\//,
+];
+const COMPLEX_TYPE_PATTERNS = ['Record<', 'Map<', '=> ', ': (', 'Promise<', 'Observable<'];
+export function isTopLevelArrayType(typeNode) {
+    if (ts.isArrayTypeNode(typeNode)) {
+        return true;
+    }
+    if (ts.isTypeReferenceNode(typeNode)) {
+        const typeName = typeNode.typeName;
+        if (ts.isIdentifier(typeName)) {
+            const name = typeName.text;
+            if (name === 'Array' || name === 'ReadonlyArray') {
+                return true;
+            }
+        }
+    }
+    if (ts.isUnionTypeNode(typeNode)) {
+        return typeNode.types.length > 0 && typeNode.types.every((t) => isTopLevelArrayType(t));
+    }
+    if (ts.isParenthesizedTypeNode(typeNode)) {
+        return isTopLevelArrayType(typeNode.type);
+    }
+    return false;
+}
+export function isRelaxedValidationPath(filePath) {
+    return RELAXED_VALIDATION_PATHS.some((pattern) => pattern.test(filePath));
+}
+export function isComplexNestedType(typeText) {
+    return COMPLEX_TYPE_PATTERNS.some((pattern) => typeText.includes(pattern));
+}
+export function isLengthAccess(node, paramName, sourceFile) {
+    if (!ts.isPropertyAccessExpression(node))
+        return false;
+    const objName = node.expression.getText(sourceFile);
+    const propName = node.name.getText(sourceFile);
+    return objName === paramName && propName === 'length';
+}
+export function isArrayIsArrayCall(node, paramName, sourceFile) {
+    if (!ts.isCallExpression(node))
+        return false;
+    const callText = node.expression.getText(sourceFile);
+    if (callText !== 'Array.isArray')
+        return false;
+    const arg = node.arguments[0]?.getText(sourceFile);
+    return arg === paramName;
+}
+export function isZodValidationCall(node, sourceFile) {
+    if (!ts.isCallExpression(node))
+        return false;
+    if (!ts.isPropertyAccessExpression(node.expression))
+        return false;
+    const methodName = node.expression.name.getText(sourceFile);
+    return methodName === 'parse' || methodName === 'safeParse';
+}
+export function isValidationFunctionCall(node) {
+    if (!ts.isCallExpression(node))
+        return false;
+    if (!ts.isIdentifier(node.expression))
+        return false;
+    const funcName = node.expression.text.toLowerCase();
+    return funcName.includes('validate') || funcName.includes('check');
+}
+export function isIterationOverParam(node, paramName, sourceFile) {
+    if (ts.isForOfStatement(node)) {
+        const iterableText = node.expression.getText(sourceFile);
+        if (iterableText === paramName || iterableText.startsWith(`${paramName}.`)) {
+            return true;
+        }
+    }
+    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
+        const objText = node.expression.expression.getText(sourceFile);
+        const methodName = node.expression.name.getText(sourceFile);
+        const iterationMethods = [
+            'forEach',
+            'map',
+            'filter',
+            'some',
+            'every',
+            'find',
+            'findIndex',
+            'findLast',
+            'findLastIndex',
+            'reduce',
+            'reduceRight',
+            'flatMap',
+            'flat',
+            'slice',
+            'includes',
+            'indexOf',
+            'lastIndexOf',
+            'join',
+            'concat',
+            'entries',
+            'values',
+            'keys',
+            'at',
+            'toSorted',
+            'toReversed',
+            'toSpliced',
+            'with',
+        ];
+        if (objText === paramName && iterationMethods.includes(methodName)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function isOutSinkUsage(node, paramName, sourceFile) {
+    if (!ts.isCallExpression(node))
+        return false;
+    if (!ts.isPropertyAccessExpression(node.expression))
+        return false;
+    const objText = node.expression.expression.getText(sourceFile);
+    if (objText !== paramName)
+        return false;
+    const methodName = node.expression.name.getText(sourceFile);
+    return methodName === 'push' || methodName === 'unshift' || methodName === 'splice';
+}
+export function isIndexedAccess(node, paramName, sourceFile) {
+    if (!ts.isElementAccessExpression(node))
+        return false;
+    return node.expression.getText(sourceFile) === paramName;
+}
+export function isSpreadOfParam(node, paramName, sourceFile) {
+    if (ts.isSpreadElement(node) || ts.isSpreadAssignment(node)) {
+        return node.expression.getText(sourceFile) === paramName;
+    }
+    return false;
+}
+export function isForwardedToCall(node, paramName, _sourceFile) {
+    if (!ts.isCallExpression(node) && !ts.isNewExpression(node))
+        return false;
+    const args = node.arguments;
+    if (!args)
+        return false;
+    for (const arg of args) {
+        if (ts.isIdentifier(arg) && arg.text === paramName) {
+            return true;
+        }
+        if (ts.isAsExpression(arg) || ts.isSatisfiesExpression(arg)) {
+            const inner = arg.expression;
+            if (ts.isIdentifier(inner) && inner.text === paramName) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+export function isShorthandPropertyReference(node, paramName) {
+    if (!ts.isShorthandPropertyAssignment(node))
+        return false;
+    return node.name.text === paramName;
+}
+export function isOptionalHandling(node, paramName, sourceFile) {
+    const nodeText = node.getText(sourceFile);
+    if (nodeText.includes(`${paramName}?.`)) {
+        return true;
+    }
+    if (ts.isBinaryExpression(node) &&
+        node.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
+        const leftText = node.left.getText(sourceFile);
+        if (leftText === paramName) {
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=array-validation-detectors.js.map

package/dist/checks/quality/data-integrity/array-validation-detectors.js.map

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

package/dist/checks/quality/data-integrity/array-validation.d.ts

@@ -3,14 +3,12 @@
  *
  * Detects array parameters without proper validation.
  * Ensures arrays are validated for length, type, and content before processing.
- *
  */
 /**
  * Check: quality/array-validation
  *
  * Detects array parameters without proper validation to prevent
  * runtime errors from unvalidated array inputs.
- *
  */
 export declare const arrayValidation: import("@opensip-cli/fitness").Check;
 //# sourceMappingURL=array-validation.d.ts.map

package/dist/checks/quality/data-integrity/array-validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"array-validation.d.ts","sourceRoot":"","sources":["../../../../src/checks/quality/data-integrity/array-validation.ts"],"names":[],"mappings":"AACA;;;;;;GAMG;AAqgBH;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,sCA4B1B,CAAC"}
+{"version":3,"file":"array-validation.d.ts","sourceRoot":"","sources":["../../../../src/checks/quality/data-integrity/array-validation.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA8JH;;;;;GAKG;AACH,eAAO,MAAM,eAAe,sCA2B1B,CAAC"}

package/dist/checks/quality/data-integrity/array-validation.js

@@ -1,340 +1,19 @@
-// @fitness-ignore-file file-length-limit -- cohesive single-check module; splitting risks breaking the detector contract
 /**
  * @fileoverview Array Parameter Validation Check
  *
  * Detects array parameters without proper validation.
  * Ensures arrays are validated for length, type, and content before processing.
- *
  */
 import { defineCheck, isTestFile } from '@opensip-cli/fitness';
 import { getSharedSourceFile } from '@opensip-cli/lang-typescript';
 import * as ts from 'typescript';
-/**
- * Quick filter keywords for array validation patterns
- */
-const QUICK_FILTER_KEYWORDS = [
-    '[]',
-    'Array',
-    'array',
-    '.length',
-    '.push',
-    '.pop',
-    '.map(',
-    '.filter(',
-];
-/**
- * Paths where array validation requirements are relaxed
- */
-const RELAXED_VALIDATION_PATHS = [
-    /\/internal\//,
-    /\/utils\//,
-    /\/helpers\//,
-    /\/cli\//,
-    /\/scripts\//,
-];
-/**
- * Type patterns that indicate complex/nested types where validation is harder to detect
- */
-const COMPLEX_TYPE_PATTERNS = [
-    'Record<',
-    'Map<',
-    '=> ', // Function type
-    ': (', // Function type with parens
-    'Promise<', // Async wrappers
-    'Observable<',
-];
-/**
- * Check whether a parameter's type is a top-level array type (e.g. `string[]`, `Array<T>`)
- * as opposed to an object/interface/intersection type that merely _contains_ array-typed
- * properties (e.g. `{ items: string[] }`, `Foo & { tags: string[] }`).
- *
- * This uses the TypeScript AST node kind rather than text matching, eliminating false
- * positives for object parameters whose nested properties happen to be arrays.
- */
-function isTopLevelArrayType(typeNode) {
-    // Direct array type: `string[]`, `Foo[]`
-    if (ts.isArrayTypeNode(typeNode)) {
-        return true;
-    }
-    // Generic Array reference: `Array<string>`, `ReadonlyArray<Foo>`
-    if (ts.isTypeReferenceNode(typeNode)) {
-        const typeName = typeNode.typeName;
-        if (ts.isIdentifier(typeName)) {
-            const name = typeName.text;
-            if (name === 'Array' || name === 'ReadonlyArray') {
-                return true;
-            }
-        }
-    }
-    // Union type: check if ALL branches are arrays (e.g. `string[] | number[]`)
-    if (ts.isUnionTypeNode(typeNode)) {
-        return typeNode.types.length > 0 && typeNode.types.every((t) => isTopLevelArrayType(t));
-    }
-    // Parenthesized type: unwrap `(string[])`
-    if (ts.isParenthesizedTypeNode(typeNode)) {
-        return isTopLevelArrayType(typeNode.type);
-    }
-    // Everything else (object literals, intersection types, type references to interfaces,
-    // mapped types, conditional types, etc.) is NOT a top-level array even if the type
-    // text contains `[]` in nested positions.
-    return false;
-}
-/**
- * Check if a file path is in a relaxed validation context
- */
-function isRelaxedValidationPath(filePath) {
-    return RELAXED_VALIDATION_PATHS.some((pattern) => pattern.test(filePath));
-}
-/**
- * Check if a type is a complex nested type where validation detection is unreliable
- */
-function isComplexNestedType(typeText) {
-    return COMPLEX_TYPE_PATTERNS.some((pattern) => typeText.includes(pattern));
-}
-/**
- * Check if node is a .length access on the parameter
- * @param node - The TypeScript AST node to check
- * @param paramName - The name of the parameter to check for
- * @param sourceFile - The TypeScript source file for text extraction
- * @returns True if the node is a .length access on the specified parameter
- */
-function isLengthAccess(node, paramName, sourceFile) {
-    if (!ts.isPropertyAccessExpression(node))
-        return false;
-    const objName = node.expression.getText(sourceFile);
-    const propName = node.name.getText(sourceFile);
-    return objName === paramName && propName === 'length';
-}
-/**
- * Check if node is an Array.isArray() call on the parameter
- * @param node - The TypeScript AST node to check
- * @param paramName - The name of the parameter to check for
- * @param sourceFile - The TypeScript source file for text extraction
- * @returns True if the node is an Array.isArray() call on the specified parameter
- */
-function isArrayIsArrayCall(node, paramName, sourceFile) {
-    if (!ts.isCallExpression(node))
-        return false;
-    const callText = node.expression.getText(sourceFile);
-    if (callText !== 'Array.isArray')
-        return false;
-    const arg = node.arguments[0]?.getText(sourceFile);
-    return arg === paramName;
-}
-/**
- * Check if node is a Zod schema validation call
- * @param node - The TypeScript AST node to check
- * @param sourceFile - The TypeScript source file for text extraction
- * @returns True if the node is a Zod .parse() or .safeParse() call
- */
-function isZodValidationCall(node, sourceFile) {
-    if (!ts.isCallExpression(node))
-        return false;
-    if (!ts.isPropertyAccessExpression(node.expression))
-        return false;
-    const methodName = node.expression.name.getText(sourceFile);
-    return methodName === 'parse' || methodName === 'safeParse';
-}
-/**
- * Check if node is a validation function call
- * @param node - The TypeScript AST node to check
- * @returns True if the node is a call to a function with 'validate' or 'check' in its name
- */
-function isValidationFunctionCall(node) {
-    if (!ts.isCallExpression(node))
-        return false;
-    if (!ts.isIdentifier(node.expression))
-        return false;
-    const funcName = node.expression.text.toLowerCase();
-    return funcName.includes('validate') || funcName.includes('check');
-}
-/**
- * Check if node is an iteration over the parameter (for...of, forEach, map, filter,
- * slice, includes, join, indexOf, concat, flat, etc.)
- *
- * Iteration implies validation because it handles empty arrays gracefully and
- * cannot blow up the runtime — the worst case is no work done.
- */
-function isIterationOverParam(node, paramName, sourceFile) {
-    // for...of statement
-    if (ts.isForOfStatement(node)) {
-        const iterableText = node.expression.getText(sourceFile);
-        if (iterableText === paramName || iterableText.startsWith(`${paramName}.`)) {
-            return true;
-        }
-    }
-    // Array prototype methods that internally iterate (and therefore handle empty
-    // arrays gracefully) or otherwise produce a bounded view. These are
-    // validation-equivalent because they don't crash on empty/short input.
-    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
-        const objText = node.expression.expression.getText(sourceFile);
-        const methodName = node.expression.name.getText(sourceFile);
-        const iterationMethods = [
-            'forEach',
-            'map',
-            'filter',
-            'some',
-            'every',
-            'find',
-            'findIndex',
-            'findLast',
-            'findLastIndex',
-            'reduce',
-            'reduceRight',
-            'flatMap',
-            'flat',
-            'slice',
-            'includes',
-            'indexOf',
-            'lastIndexOf',
-            'join',
-            'concat',
-            'entries',
-            'values',
-            'keys',
-            'at',
-            'toSorted',
-            'toReversed',
-            'toSpliced',
-            'with',
-        ];
-        if (objText === paramName && iterationMethods.includes(methodName)) {
-            return true;
-        }
-    }
-    return false;
-}
-/**
- * Check if node is a write-only sink usage of the parameter.
- *
- * Out-array sinks (`bucket.push(...)`, `bucket.unshift(...)`) flag the param
- * as a producer target — the function isn't *consuming* the array, it's
- * writing into it. Validation belongs at the consumer, not the producer.
- */
-function isOutSinkUsage(node, paramName, sourceFile) {
-    if (!ts.isCallExpression(node))
-        return false;
-    if (!ts.isPropertyAccessExpression(node.expression))
-        return false;
-    const objText = node.expression.expression.getText(sourceFile);
-    if (objText !== paramName)
-        return false;
-    const methodName = node.expression.name.getText(sourceFile);
-    // Mutating sink methods — caller is producing into the array.
-    return methodName === 'push' || methodName === 'unshift' || methodName === 'splice';
-}
-/**
- * Check if node is indexed access on the parameter (`param[i]`).
- *
- * Indexed access on a typed array yields `T | undefined` under
- * `noUncheckedIndexedAccess`; under any reasonable consumer it implies
- * defensive use and cannot crash on empty/short input the way an
- * unconditional `.length`-less iteration would. Practically: if the body
- * does `param[i]`, the author has already structured the access around
- * length (or expects undefined).
- */
-function isIndexedAccess(node, paramName, sourceFile) {
-    if (!ts.isElementAccessExpression(node))
-        return false;
-    return node.expression.getText(sourceFile) === paramName;
-}
-/**
- * Check if node is a spread of the parameter (`...param`) inside a call
- * argument list, array literal, or object literal.
- *
- * Spread iterates the array — equivalent to `for...of`.
- */
-function isSpreadOfParam(node, paramName, sourceFile) {
-    if (ts.isSpreadElement(node) || ts.isSpreadAssignment(node)) {
-        return node.expression.getText(sourceFile) === paramName;
-    }
-    return false;
-}
-/**
- * Check if node passes the parameter through to another function call.
- *
- * A pure pass-through forwarder (`return otherFn(..., param, ...)`) defers
- * validation to the destination function — flagging the forwarder is a false
- * positive, since the wrapper has nothing to validate against. The destination
- * function (which actually consumes the array) is the meaningful validation
- * site.
- *
- * Restricted to call-argument position (not the callee position) so we don't
- * match the param being treated as a function.
- */
-function isForwardedToCall(node, paramName, _sourceFile) {
-    if (!ts.isCallExpression(node) && !ts.isNewExpression(node))
-        return false;
-    const args = node.arguments;
-    /* v8 ignore next -- defensive AST/type guard */
-    if (!args)
-        return false;
-    for (const arg of args) {
-        if (ts.isIdentifier(arg) && arg.text === paramName) {
-            return true;
-        }
-        // `Array.from(param)`, `[...param]`, etc. handled by isSpreadOfParam.
-        // Type-cast forwards: `someFn(param as Foo)` or `someFn(param satisfies Foo)`.
-        if (ts.isAsExpression(arg) || ts.isSatisfiesExpression(arg)) {
-            const inner = arg.expression;
-            if (ts.isIdentifier(inner) && inner.text === paramName) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-/**
- * Check if node is a property-shorthand reference to the parameter inside
- * an object literal (`return { param }`).
- *
- * The param value is being copied by reference into a result object — no
- * iteration, no boundary crossing, the consumer of the returned object is
- * the meaningful validation site (same logic as `isForwardedToCall`).
- */
-function isShorthandPropertyReference(node, paramName) {
-    if (!ts.isShorthandPropertyAssignment(node))
-        return false;
-    return node.name.text === paramName;
-}
-/**
- * Check if node is an optional chaining or nullish coalescing on the parameter
- */
-function isOptionalHandling(node, paramName, sourceFile) {
-    const nodeText = node.getText(sourceFile);
-    // Optional chaining: param?.length, param?.map
-    if (nodeText.includes(`${paramName}?.`)) {
-        return true;
-    }
-    /* v8 ignore next -- defensive nullish fallback */
-    // Nullish coalescing: param ?? []
-    if (ts.isBinaryExpression(node) &&
-        node.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
-        const leftText = node.left.getText(sourceFile);
-        if (leftText === paramName) {
-            return true;
-        }
-    }
-    return false;
-}
-/**
- * Check if function body contains array validation for the parameter
- * @param node - The function declaration, method, or arrow function node
- * @param param - The parameter declaration to check for validation
- * @param sourceFile - The TypeScript source file for text extraction
- * @returns True if the function body contains validation for the array parameter
- */
+import { isArrayIsArrayCall, isComplexNestedType, isForwardedToCall, isIndexedAccess, isIterationOverParam, isLengthAccess, isOptionalHandling, isOutSinkUsage, isRelaxedValidationPath, isShorthandPropertyReference, isSpreadOfParam, isTopLevelArrayType, isValidationFunctionCall, isZodValidationCall, QUICK_FILTER_KEYWORDS, } from './array-validation-detectors.js';
 function checkForArrayValidation(node, param, sourceFile) {
-    /* v8 ignore next -- defensive guard */
     if (!node.body)
         return false;
     const paramName = ts.isIdentifier(param.name) ? param.name.text : null;
-    /* v8 ignore next -- defensive AST/type guard */
     if (!paramName)
-        return true; // Destructured params are harder to track, assume validated
-    // Underscore-prefixed params are an established TS convention for
-    // "intentionally unused" — the body does not consume them, so demanding
-    // validation is meaningless.
+        return true;
     if (paramName.startsWith('_'))
         return true;
     let hasValidation = false;
@@ -351,33 +30,24 @@ function checkForArrayValidation(node, param, sourceFile) {
         if (isValidationFunctionCall(n)) {
             hasValidation = true;
         }
-        // Iteration patterns imply graceful handling of arrays
         if (isIterationOverParam(n, paramName, sourceFile)) {
             hasValidation = true;
         }
-        // Optional chaining/nullish coalescing implies null safety
         if (isOptionalHandling(n, paramName, sourceFile)) {
             hasValidation = true;
         }
-        // Out-array sinks (param.push(...)) — param is a producer target, not a
-        // consumer input. Validation belongs at the consumer.
         if (isOutSinkUsage(n, paramName, sourceFile)) {
             hasValidation = true;
         }
-        // Indexed access (param[i]) — defensive, bounded by author intent.
         if (isIndexedAccess(n, paramName, sourceFile)) {
             hasValidation = true;
         }
-        // Spread (...param) — iterates the array, equivalent to for...of.
         if (isSpreadOfParam(n, paramName, sourceFile)) {
             hasValidation = true;
         }
-        // Forwarded to another call — destination owns validation.
         if (isForwardedToCall(n, paramName, sourceFile)) {
             hasValidation = true;
         }
-        // Property-shorthand reference ({ param }) — pass-through into a result
-        // object; consumer of the result owns validation.
         if (isShorthandPropertyReference(n, paramName)) {
             hasValidation = true;
         }
@@ -388,38 +58,22 @@ function checkForArrayValidation(node, param, sourceFile) {
     visit(node.body);
     return hasValidation;
 }
-/**
- * Check function parameters for unvalidated arrays
- * Note: Ignore directives are handled at the framework level in defineCheck()
- * @param {CheckFunctionArrayParamsOptions} options - The check options
- * @returns Array of violations
- */
 function checkFunctionArrayParams(options) {
     const { node, sourceFile, absolutePath } = options;
     const violations = [];
-    // Skip files in relaxed validation paths
     if (isRelaxedValidationPath(absolutePath)) {
         return violations;
     }
-    // Skip abstract methods (can't have validation in body)
     if (ts.isMethodDeclaration(node) &&
         node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AbstractKeyword)) {
         return violations;
     }
-    // Filter to array parameters without validation
     const unvalidatedArrayParams = node.parameters.filter((param) => {
         if (!param.type)
             return false;
-        // Primary gate: use AST to determine if the parameter's type is a top-level
-        // array type.  Object/interface/intersection types whose *properties* are
-        // arrays will correctly return false here, eliminating the largest category
-        // of false positives.
         if (!isTopLevelArrayType(param.type))
             return false;
         const typeText = param.type.getText(sourceFile);
-        // Secondary gate: skip complex/nested types where validation detection is
-        // unreliable (Map values, Record values, function types, Promises, etc.)
-        /* v8 ignore next -- defensive AST/type guard */
         if (isComplexNestedType(typeText))
             return false;
         return !checkForArrayValidation(node, param, sourceFile);
@@ -441,25 +95,15 @@ function checkFunctionArrayParams(options) {
     }
     return violations;
 }
-/**
- * Analyze a file for array validation issues
- * @param content - The file content as a string
- * @param absolutePath - The absolute path to the file being analyzed
- * @returns Array of violations found in the file
- */
 function analyzeFile(content, absolutePath) {
     const violations = [];
-    // Quick filter: skip files without array-related patterns
     if (!QUICK_FILTER_KEYWORDS.some((kw) => content.includes(kw))) {
         return violations;
     }
-    // Note: Ignore directives are handled at the framework level in defineCheck()
     const sourceFile = getSharedSourceFile(absolutePath, content);
-    /* v8 ignore next -- defensive guard */
     if (!sourceFile)
         return [];
     const visit = (node) => {
-        // Check function parameters with array types
         if (ts.isFunctionDeclaration(node) ||
             ts.isMethodDeclaration(node) ||
             ts.isArrowFunction(node)) {
@@ -475,7 +119,6 @@ function analyzeFile(content, absolutePath) {
  *
  * Detects array parameters without proper validation to prevent
  * runtime errors from unvalidated array inputs.
- *
  */
 export const arrayValidation = defineCheck({
     id: 'a9e0e70c-a4af-42e6-bbd7-4c87a72cb7d4',
@@ -499,7 +142,6 @@ export const arrayValidation = defineCheck({
     tags: ['quality', 'validation', 'type-safety', 'arrays'],
     fileTypes: ['ts'],
     analyze(content, filePath) {
-        // Skip test files — array parameter validation in tests is low-risk due to controlled inputs
         if (isTestFile(filePath))
             return [];
         return analyzeFile(content, filePath);