@opensip-cli/checks-typescript 0.1.0

package/dist/checks/quality/patterns/result-pattern-consistency.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @fileoverview Result Pattern Consistency Check
+ *
+ * Enforces consistent use of Result<T,E> vs throw based on error type:
+ * - Result<T,E> for expected failures (validation, not found, business rules)
+ * - throw for unexpected failures (system errors, security issues)
+ *
+ * @see CLAUDE.md Error Handling Policy
+ */
+/**
+ * Check: quality/result-pattern-consistency
+ *
+ * Ensures consistent use of Result<T,E> for expected failures and throw for unexpected failures.
+ */
+export declare const resultPatternConsistency: import("@opensip-cli/fitness").Check;
+//# sourceMappingURL=result-pattern-consistency.d.ts.map

package/dist/checks/quality/patterns/result-pattern-consistency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-pattern-consistency.d.ts","sourceRoot":"","sources":["../../../../src/checks/quality/patterns/result-pattern-consistency.ts"],"names":[],"mappings":"AACA;;;;;;;;GAQG;AA8SH;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,sCAsEnC,CAAC"}

package/dist/checks/quality/patterns/result-pattern-consistency.js

@@ -0,0 +1,328 @@
+// @fitness-ignore-file canonical-result-usage -- References Result pattern in JSDoc for check documentation, not actual Result usage
+/**
+ * @fileoverview Result Pattern Consistency Check
+ *
+ * Enforces consistent use of Result<T,E> vs throw based on error type:
+ * - Result<T,E> for expected failures (validation, not found, business rules)
+ * - throw for unexpected failures (system errors, security issues)
+ *
+ * @see CLAUDE.md Error Handling Policy
+ */
+import { defineCheck } from '@opensip-cli/fitness';
+import { getSharedSourceFile } from '@opensip-cli/lang-typescript';
+import * as ts from 'typescript';
+/**
+ * Expected error types that should use Result pattern
+ */
+const EXPECTED_ERROR_TYPES = [
+    'ValidationError',
+    'NotFoundError',
+    'BusinessRuleError',
+    'ConflictError',
+    'InvalidInputError',
+    'DuplicateError',
+];
+/**
+ * Function name patterns where throwing is legitimate (validation/guard helpers
+ * + infrastructure-boundary factories, resolvers, loaders, parsers, mappers).
+ *
+ * Factory/resolver/loader helpers (`defineX`, `resolveX`, `loadX`, `parseX`,
+ * `mapXTo…`) are startup-time configuration entry points: a malformed input
+ * is a programmer error caught once at boot rather than a recoverable
+ * business-logic failure, so they throw eagerly. Forcing them to return
+ * `Result` would push a startup-error branch into every call site — a
+ * usability regression, not consistency.
+ */
+const LEGITIMATE_THROW_FUNCTION_PATTERNS = [
+    /^validate[A-Z]/,
+    /^assert[A-Z]/,
+    /^ensure[A-Z]/,
+    /^require[A-Z]/,
+    /^check[A-Z]/,
+    /^verify[A-Z]/,
+    /^must[A-Z]/,
+    /^define[A-Z]/,
+    /^resolve[A-Z]/,
+    /^load[A-Z]/,
+    /^parse[A-Z]/,
+    /^map[A-Z]\w*To[A-Z]/,
+    /Guard$/,
+    /Validator$/,
+    /Assertion$/,
+];
+/**
+ * Paths where throwing is expected (infrastructure boundaries per DEC-015).
+ * These are entry points that bridge external systems, CLI, or pipeline layers
+ * where callers can't meaningfully recover — throw is the correct pattern.
+ */
+const THROW_ALLOWED_PATHS = [
+    /\/routes\//,
+    /\/handlers\//,
+    /\/controllers\//,
+    /\/middleware\//,
+    /\/plugins?\//,
+    /\/bootstrap/,
+    /\/providers\//,
+    // Internal services
+    /\/services\/internal\//,
+    // Validation utilities
+    /\/utils\/validation/,
+    // LLM and external API adapters (bridge external services)
+    /\/llm\//,
+    /\/adapters\//,
+    /\/embeddings\//,
+    // CLI command entry points (bridge CLI to domain)
+    /\/commands\//,
+    // Pipeline governance and orchestration boundaries
+    /\/governor\//,
+    /\/prompt\//,
+    // ID parsing/validation (infrastructure boundary for data integrity)
+    /\/ids\//,
+    // Infrastructure boundary packages and patterns (DEC-015: throw is correct)
+    /packages\/infrastructure\//,
+    /\/stores\//,
+    /\/registry\//,
+];
+/**
+ * File name patterns where throwing is legitimate (infrastructure boundary classes)
+ */
+const INFRASTRUCTURE_FILE_PATTERNS = [/registry/i, /-registry/i, /store/i, /-store/i, /adapter/i];
+/**
+ * Check if a file path is in a throw-allowed context
+ */
+function isThrowAllowedPath(filePath) {
+    if (THROW_ALLOWED_PATHS.some((pattern) => pattern.test(filePath))) {
+        return true;
+    }
+    // Check file name against infrastructure patterns (registries, stores, adapters)
+    /* v8 ignore next -- defensive nullish fallback */
+    const fileName = filePath.split('/').pop() ?? '';
+    return INFRASTRUCTURE_FILE_PATTERNS.some((pattern) => pattern.test(fileName));
+}
+/**
+ * Check if a function name indicates it's a validation/guard helper
+ */
+function isValidationHelper(funcName) {
+    return LEGITIMATE_THROW_FUNCTION_PATTERNS.some((pattern) => pattern.test(funcName));
+}
+/**
+ * Check if a throw statement is inside a catch block (re-throw pattern)
+ */
+function isInCatchBlock(node) {
+    let current = node.parent;
+    while (current) {
+        if (ts.isCatchClause(current)) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
+/**
+ * Get the containing function name for a node
+ */
+function getContainingFunctionName(node, sourceFile) {
+    let current = node.parent;
+    while (current) {
+        if (ts.isFunctionDeclaration(current) && current.name) {
+            return current.name.getText(sourceFile);
+        }
+        /* v8 ignore next -- defensive AST/type guard */
+        if (ts.isMethodDeclaration(current) && current.name) {
+            return current.name.getText(sourceFile);
+        }
+        /* v8 ignore next -- defensive AST/type guard */
+        if (ts.isArrowFunction(current) || ts.isFunctionExpression(current)) {
+            const parent = current.parent;
+            if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
+                return parent.name.getText(sourceFile);
+            }
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
+/**
+ * Check if a node is inside a constructor (constructors should throw, not return Result)
+ */
+function isInConstructor(node) {
+    let current = node.parent;
+    while (current) {
+        if (ts.isConstructorDeclaration(current)) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
+/**
+ * Check if a node is inside a private method (private methods may throw for internal consistency)
+ */
+function isInPrivateMethod(node) {
+    let current = node.parent;
+    while (current) {
+        if (ts.isMethodDeclaration(current)) {
+            const modifiers = ts.getModifiers(current);
+            if (modifiers?.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword)) {
+                return true;
+            }
+        }
+        current = current.parent;
+    }
+    return false;
+}
+/**
+ * Checks a throw statement for expected error types that should use Result pattern
+ */
+function checkThrowStatement(options) {
+    const { node, sourceFile, filePath } = options;
+    // Skip files in throw-allowed paths (routes, handlers, plugins)
+    if (isThrowAllowedPath(filePath)) {
+        return null;
+    }
+    // Skip re-throws in catch blocks (error wrapping is legitimate)
+    if (isInCatchBlock(node)) {
+        return null;
+    }
+    // Skip constructors (constructor validation should throw, not return Result)
+    if (isInConstructor(node)) {
+        return null;
+    }
+    // Skip private methods (internal consistency checks may throw)
+    if (isInPrivateMethod(node)) {
+        return null;
+    }
+    // Skip validation/guard helper functions
+    const funcName = getContainingFunctionName(node, sourceFile);
+    if (funcName && isValidationHelper(funcName)) {
+        return null;
+    }
+    const throwText = node.expression.getText(sourceFile);
+    // Find the first matching expected error type
+    const matchedErrorType = EXPECTED_ERROR_TYPES.find((errorType) => throwText.includes(errorType));
+    if (!matchedErrorType) {
+        return null;
+    }
+    const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+    const lineNum = line + 1;
+    const matchText = node.getText(sourceFile);
+    return {
+        line: lineNum,
+        column: character + 1,
+        message: `Throwing ${matchedErrorType} instead of returning Result`,
+        severity: 'warning',
+        suggestion: `Replace 'throw new ${matchedErrorType}(...)' with 'return err(new ${matchedErrorType}(...))' and update the function return type to Result<T, ${matchedErrorType}>`,
+        match: matchText,
+    };
+}
+/**
+ * Checks function body for thrown expected errors when return type is Result
+ */
+function checkResultFunctionBody(options) {
+    const { bodyText, node, sourceFile, filePath } = options;
+    // Skip files in throw-allowed paths
+    if (isThrowAllowedPath(filePath)) {
+        return null;
+    }
+    // Skip private methods (internal consistency checks may throw)
+    /* v8 ignore next -- defensive AST/type guard */
+    if (ts.isMethodDeclaration(node)) {
+        const modifiers = ts.getModifiers(node);
+        if (modifiers?.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword)) {
+            return null;
+        }
+    }
+    // Get function name
+    const funcName = ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node)
+        ? node.name?.getText(sourceFile)
+        : undefined;
+    // Skip validation helper functions
+    if (funcName && isValidationHelper(funcName)) {
+        return null;
+    }
+    for (const errorType of EXPECTED_ERROR_TYPES) {
+        if (!bodyText.includes(`throw new ${errorType}`))
+            continue;
+        const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+        const lineNum = line + 1;
+        const matchText = `throw new ${errorType}`;
+        return {
+            line: lineNum,
+            column: character + 1,
+            message: `Function returns Result but throws ${errorType}`,
+            severity: 'error',
+            suggestion: `This function declares Result<T,E> return type but throws ${errorType}. Replace 'throw new ${errorType}(...)' with 'return err(new ${errorType}(...))' for consistency`,
+            match: matchText,
+        };
+    }
+    return null;
+}
+/**
+ * Check: quality/result-pattern-consistency
+ *
+ * Ensures consistent use of Result<T,E> for expected failures and throw for unexpected failures.
+ */
+export const resultPatternConsistency = defineCheck({
+    id: '137e8d24-8b06-4d1f-b5f0-e7542d932679',
+    slug: 'result-pattern-consistency',
+    scope: { languages: ['typescript'], concerns: ['backend', 'server'] },
+    contentFilter: 'strip-strings',
+    confidence: 'high',
+    description: 'Ensures consistent use of Result<T,E> for expected failures and throw for unexpected failures',
+    longDescription: `**Purpose:** Enforces that expected failures (validation, not-found, business rules) use \`Result<T,E>\` while \`throw\` is reserved for unexpected failures (DEC-015).
+
+**Detects:** Analyzes each file individually using TypeScript AST. Checks for:
+- \`throw new\` statements using expected error types (\`ValidationError\`, \`NotFoundError\`, \`BusinessRuleError\`, \`ConflictError\`, \`InvalidInputError\`, \`DuplicateError\`) outside catch blocks and non-validation helper functions
+- Functions with \`Result\` return type that also contain \`throw new <ExpectedError>\` statements
+
+**Why it matters:** Mixing throw and Result for the same error category forces callers to handle both patterns, creating inconsistent and fragile error handling.
+
+**Scope:** Codebase-specific convention (see CLAUDE.md Error Handling Policy)`,
+    tags: ['error-handling', 'quality', 'best-practices'],
+    fileTypes: ['ts'],
+    analyze(content, filePath) {
+        // Quick filter: skip files without error patterns
+        const hasErrorPatterns = content.includes('throw') || content.includes('Result');
+        if (!hasErrorPatterns) {
+            return [];
+        }
+        const violations = [];
+        const sourceFile = getSharedSourceFile(filePath, content);
+        /* v8 ignore next -- defensive guard */
+        if (!sourceFile)
+            return [];
+        const visit = (node) => {
+            ts.forEachChild(node, visit);
+            // Check throw statements for expected error types
+            if (ts.isThrowStatement(node)) {
+                const violation = checkThrowStatement({ node, sourceFile, filePath });
+                if (violation) {
+                    violations.push(violation);
+                }
+                return;
+            }
+            // Check functions that return Result but also throw expected errors
+            if (!ts.isFunctionDeclaration(node) && !ts.isMethodDeclaration(node))
+                return;
+            const returnType = node.type?.getText(sourceFile);
+            // Require the canonical generic form `Result<…>` (also matches
+            // `Promise<Result<…>>`). A bare substring match for "Result"
+            // misclassifies domain types like `GateCompareResult`, `AnalyzeResult`,
+            // or `ParseResult` as Result-returning and produces false positives
+            // wherever such a function throws on a legitimate infrastructure
+            // boundary. Word-boundary + `<` preserves the intent without matching
+            // unrelated trailing-token names.
+            if (!returnType || !/\bResult\s*</.test(returnType))
+                return;
+            /* v8 ignore next -- defensive nullish fallback */
+            const bodyText = node.body?.getText(sourceFile) ?? '';
+            const violation = checkResultFunctionBody({ bodyText, node, sourceFile, filePath });
+            if (violation) {
+                violations.push(violation);
+            }
+        };
+        visit(sourceFile);
+        return violations;
+    },
+});
+//# sourceMappingURL=result-pattern-consistency.js.map

package/dist/checks/quality/patterns/result-pattern-consistency.js.map

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

package/dist/checks/quality/patterns/silent-early-returns.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @fileoverview Silent Early Returns Check
+ *
+ * Detects validation/guard paths that return silently without logging.
+ * These patterns make debugging difficult by hiding why code paths weren't executed.
+ */
+/**
+ * Check: quality/silent-early-returns
+ *
+ * Detects single-line early returns (if (!x) return null/false) without logging.
+ * These patterns make it impossible to know why a code path wasn't executed.
+ *
+ * Exceptions:
+ * - Type guards (functions that return `x is T`)
+ * - Boolean predicate functions (isXxx, hasXxx, canXxx, shouldXxx)
+ * - Predicate callbacks (filter, find, some, every, map, etc.) where false/null means "skip item"
+ * - Validation/utility functions (validate, verify, parse, check, get, test, compare, supports, etc.)
+ * - Code with `// @silent-ok` marker
+ * - Code with nearby logging
+ * - Fitness check and framework source files (excluded from scanning)
+ */
+export declare const silentEarlyReturns: import("@opensip-cli/fitness").Check;
+//# sourceMappingURL=silent-early-returns.d.ts.map

package/dist/checks/quality/patterns/silent-early-returns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"silent-early-returns.d.ts","sourceRoot":"","sources":["../../../../src/checks/quality/patterns/silent-early-returns.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAuQH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,kBAAkB,sCAgD7B,CAAC"}

package/dist/checks/quality/patterns/silent-early-returns.js

@@ -0,0 +1,266 @@
+/**
+ * @fileoverview Silent Early Returns Check
+ *
+ * Detects validation/guard paths that return silently without logging.
+ * These patterns make debugging difficult by hiding why code paths weren't executed.
+ */
+import { logger } from '@opensip-cli/core';
+import { defineCheck } from '@opensip-cli/fitness';
+import { getSharedSourceFile } from '@opensip-cli/lang-typescript';
+import * as ts from 'typescript';
+/**
+ * Patterns that indicate logging is present
+ */
+const LOGGING_PATTERNS = [/logger\./, /console\./, /\.log\(/];
+/**
+ * Patterns that indicate intentional silent return
+ */
+const MARKER_PATTERNS = [/@silent-ok/, /\/\/\s*type\s*guard/i];
+/**
+ * Sentinel return value kinds
+ */
+const SENTINEL_KINDS = new Set([ts.SyntaxKind.NullKeyword, ts.SyntaxKind.FalseKeyword]);
+// =============================================================================
+// HELPER FUNCTIONS
+// =============================================================================
+/**
+ * Find the enclosing function for a node.
+ *
+ * Intentionally narrower than `lang-typescript`'s `findEnclosingFunction` —
+ * skips past `ConstructorDeclaration` and `FunctionExpression` parents to
+ * find the next enclosing declaration/method/arrow whose name (if any) the
+ * downstream predicates (`isTypeGuard`, `isValidationOrParserFunction`) can
+ * inspect. Switching to the canonical helper would change behavior for
+ * `if (!x) return null` directly inside a constructor body.
+ */
+function findFunction(node) {
+    let current = node.parent;
+    while (current) {
+        if (ts.isFunctionDeclaration(current) ||
+            ts.isMethodDeclaration(current) ||
+            ts.isArrowFunction(current)) {
+            return current;
+        }
+        current = current.parent;
+    }
+    return null;
+}
+/**
+ * Check if a function is a type guard or boolean predicate
+ * - Type guards: functions that return `x is T`
+ * - Predicate functions: isXxx, hasXxx, canXxx, shouldXxx
+ */
+function isTypeGuard(fn, sourceFile) {
+    // Check return type predicate
+    if (fn.type?.getText(sourceFile).includes(' is ')) {
+        return true;
+    }
+    // Check function name matches predicate patterns
+    if ((ts.isFunctionDeclaration(fn) || ts.isMethodDeclaration(fn)) && fn.name) {
+        const name = fn.name.getText(sourceFile);
+        // Predicate function patterns: isXxx, hasXxx, canXxx, shouldXxx
+        if (/^(is|has|can|should)[A-Z]/.test(name)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Check if a function is a validation/parsing function where silent returns are expected.
+ * These functions legitimately return null/false for invalid input.
+ */
+function isValidationOrParserFunction(fn, sourceFile) {
+    // Get function name if available
+    if ((ts.isFunctionDeclaration(fn) || ts.isMethodDeclaration(fn)) && fn.name) {
+        const name = fn.name.getText(sourceFile);
+        // Validation/parsing function patterns: validate*, verify*, parse*, check*, extract*, get*OrNull, etc.
+        if (
+        // eslint-disable-next-line sonarjs/regex-complexity -- exhaustive list of known validator/parser prefixes; readable as written
+        /^(validate|verify|parse|check|extract|try|attempt|find|get\w*OrNull|get|lookup|resolve|match|unregister|acquire|release|test|compare|supports)[A-Z]?/.test(name)) {
+            return true;
+        }
+    }
+    // Check return type - functions returning T | null or T | undefined are validators
+    if (fn.type) {
+        const returnType = fn.type.getText(sourceFile);
+        if (returnType.includes('| null') || returnType.includes('| undefined')) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Check if a return is a guard clause at the start of a function (first 3 statements).
+ * Early guard clauses are a common defensive coding pattern.
+ */
+function isEarlyGuardClause(returnNode, fn) {
+    const body = fn.body;
+    /* v8 ignore next -- defensive AST/type guard */
+    if (!body || !ts.isBlock(body))
+        return false;
+    const statements = body.statements;
+    for (let i = 0; i < Math.min(statements.length, 3); i++) {
+        if (statements[i] === returnNode) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Array predicate methods where returning false is intentional filtering
+ */
+const PREDICATE_METHODS = new Set([
+    'filter',
+    'find',
+    'findIndex',
+    'findLast',
+    'findLastIndex',
+    'some',
+    'every',
+    'map',
+]);
+/**
+ * Check if a function is a callback in an array predicate method
+ * Example: arr.filter(x => { if (!x) return false; ... })
+ */
+function isPredicateCallback(fn) {
+    // Only arrow functions can be predicate callbacks
+    if (!ts.isArrowFunction(fn))
+        return false;
+    // Check if parent is a call expression argument
+    const parent = fn.parent;
+    /* v8 ignore next -- defensive AST/type guard */
+    if (!ts.isCallExpression(parent))
+        return false;
+    // Check if the call is a method call
+    const callee = parent.expression;
+    /* v8 ignore next -- defensive AST/type guard */
+    if (!ts.isPropertyAccessExpression(callee))
+        return false;
+    // Check if method name is a predicate method
+    const methodName = callee.name.getText();
+    return PREDICATE_METHODS.has(methodName);
+}
+function extractReturnStatement(node) {
+    if (ts.isReturnStatement(node.thenStatement)) {
+        return node.thenStatement;
+    }
+    /* v8 ignore next -- defensive AST/type guard */
+    if (ts.isBlock(node.thenStatement) && node.thenStatement.statements.length === 1) {
+        const statement = node.thenStatement.statements[0];
+        if (statement && ts.isReturnStatement(statement)) {
+            return statement;
+        }
+    }
+    return null;
+}
+function isSentinelReturn(returnStatement) {
+    return Boolean(returnStatement?.expression && SENTINEL_KINDS.has(returnStatement.expression.kind));
+}
+function shouldSkipForFunction(node, sourceFile) {
+    const fn = findFunction(node);
+    /* v8 ignore next -- defensive AST/type guard */
+    if (!fn)
+        return false;
+    return (isTypeGuard(fn, sourceFile) ||
+        isPredicateCallback(fn) ||
+        isValidationOrParserFunction(fn, sourceFile) ||
+        isEarlyGuardClause(node, fn));
+}
+function hasLoggingOrMarkerInContext(node, content) {
+    /* v8 ignore next -- defensive non-negative guard */
+    const start = Math.max(0, node.getStart() - 200);
+    const context = content.slice(start, node.getEnd());
+    return (LOGGING_PATTERNS.some((p) => p.test(context)) || MARKER_PATTERNS.some((p) => p.test(context)));
+}
+function createSilentReturnViolation(node, returnStatement, sourceFile) {
+    const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+    /* v8 ignore next -- defensive AST/type guard */
+    const val = returnStatement.expression.kind === ts.SyntaxKind.NullKeyword ? 'null' : 'false';
+    return {
+        line: line + 1,
+        column: 0,
+        message: `Silent early return (${val}) without logging`,
+        severity: 'error',
+        // @fitness-ignore-next-line logging-standards -- String literal in suggestion text, not actual logger call
+        suggestion: `Add logging: \`if (cond) { logger.info({ evt: 'validation.failed' }); return ${val}; }\``,
+        match: `return ${val}`,
+    };
+}
+function checkSilentReturn(node, sourceFile, content) {
+    const returnStatement = extractReturnStatement(node);
+    if (!isSentinelReturn(returnStatement)) {
+        return null;
+    }
+    if (shouldSkipForFunction(node, sourceFile)) {
+        return null;
+    }
+    if (hasLoggingOrMarkerInContext(node, content)) {
+        return null;
+    }
+    return createSilentReturnViolation(node, returnStatement, sourceFile);
+}
+// =============================================================================
+// CHECK IMPLEMENTATION
+// =============================================================================
+/**
+ * Check: quality/silent-early-returns
+ *
+ * Detects single-line early returns (if (!x) return null/false) without logging.
+ * These patterns make it impossible to know why a code path wasn't executed.
+ *
+ * Exceptions:
+ * - Type guards (functions that return `x is T`)
+ * - Boolean predicate functions (isXxx, hasXxx, canXxx, shouldXxx)
+ * - Predicate callbacks (filter, find, some, every, map, etc.) where false/null means "skip item"
+ * - Validation/utility functions (validate, verify, parse, check, get, test, compare, supports, etc.)
+ * - Code with `// @silent-ok` marker
+ * - Code with nearby logging
+ * - Fitness check and framework source files (excluded from scanning)
+ */
+export const silentEarlyReturns = defineCheck({
+    id: '9585ae15-45ea-404c-91b5-91baad7b4de0',
+    slug: 'silent-early-returns',
+    scope: { languages: ['typescript'], concerns: ['backend', 'server'] },
+    contentFilter: 'strip-strings',
+    description: 'Detect single-line early returns without logging',
+    longDescription: `**Purpose:** Detects validation/guard paths that return sentinel values (\`null\` or \`false\`) without logging, making debugging difficult.
+
+**Detects:** Analyzes each file individually using TypeScript AST. Finds \`if\` statements (without \`else\`) whose then-branch is a single \`return null\` or \`return false\` with no nearby logging (\`logger.\`, \`console.\`) or \`@silent-ok\` marker. Excludes type guards (\`is/has/can/should\` prefixes), predicate callbacks (\`filter\`, \`find\`, \`some\`, \`every\`, \`map\`), validation/parser/utility functions (validate, verify, parse, check, extract, try, attempt, find, get, lookup, resolve, match, unregister, acquire, release, test, compare, supports), early guard clauses (first 3 statements), and fitness check/framework source files.
+
+**Why it matters:** Silent early returns make it impossible to diagnose why a code path was not executed, turning simple issues into hours-long debugging sessions.
+
+**Scope:** General best practice`,
+    tags: ['quality', 'observability', 'validation'],
+    fileTypes: ['ts'],
+    confidence: 'medium',
+    analyze(content, filePath) {
+        logger.debug({
+            evt: 'fitness.check.silent_early_returns.analyze',
+            msg: 'Analyzing file for silent early return patterns',
+            filePath,
+        });
+        // Quick filter: must have potential silent returns
+        if (!content.includes('return null') && !content.includes('return false')) {
+            return [];
+        }
+        const violations = [];
+        const sourceFile = getSharedSourceFile(filePath, content);
+        /* v8 ignore next -- defensive guard */
+        if (!sourceFile)
+            return [];
+        const visit = (node) => {
+            // Only check if statements without else (single-line guards)
+            if (ts.isIfStatement(node) && !node.elseStatement) {
+                const violation = checkSilentReturn(node, sourceFile, content);
+                if (violation) {
+                    violations.push(violation);
+                }
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+        return violations;
+    },
+});
+//# sourceMappingURL=silent-early-returns.js.map

package/dist/checks/quality/patterns/silent-early-returns.js.map

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