@opensip-cli/checks-typescript 0.1.0

package/dist/checks/quality/patterns/async-waterfall-detection.js

@@ -0,0 +1,410 @@
+// @fitness-ignore-file file-length-limit -- Complex module with tightly coupled logic; splitting would fragment cohesive functionality
+// @fitness-ignore-file null-safety -- null checks are intentional guards
+/**
+ * @fileoverview Async Waterfall Detection Check
+ *
+ * Detects sequential await statements that could potentially be parallelized
+ * with Promise.all(). Uses AST-aware heuristics:
+ * - Looks for consecutive lines with await expressions
+ * - Flags when the second await doesn't reference the variable from the first
+ * - Skips awaits in different conditional branches (if/else, ternary, switch)
+ * - Recognizes dynamic import destructuring dependencies
+ * - Skips mutex/lock acquire-then-execute patterns
+ * - Skips sleep/delay in polling loops
+ */
+import { defineCheck, isTestFile } from '@opensip-cli/fitness';
+import { getSharedSourceFile, isAsync } from '@opensip-cli/lang-typescript';
+import * as ts from 'typescript';
+/**
+ * Minimum line gap to consider awaits as consecutive (0 = adjacent lines)
+ */
+const MAX_LINE_GAP = 1;
+/**
+ * Function names that indicate sleep/delay/timer patterns (inherently sequential)
+ */
+const SLEEP_DELAY_NAMES = new Set(['sleep', 'delay', 'wait', 'setTimeout', 'pause']);
+/**
+ * Function names that indicate mutex/lock acquire patterns (inherently sequential)
+ */
+const LOCK_ACQUIRE_NAMES = new Set(['acquire', 'lock', 'runExclusive', 'withLock']);
+/**
+ * Check if a node is an async function (function, method, or arrow function).
+ *
+ * Defers the modifier inspection to `lang-typescript`'s canonical `isAsync`
+ * (modern `canHaveModifiers` + `getModifiers` API); the function-like guard
+ * stays inline so callers downstream still get the narrowed-via-control-flow
+ * type for `node` at the call site.
+ */
+function isAsyncFunction(node) {
+    if (ts.isFunctionDeclaration(node) ||
+        ts.isMethodDeclaration(node) ||
+        ts.isArrowFunction(node) ||
+        ts.isFunctionExpression(node)) {
+        return isAsync(node);
+    }
+    return false;
+}
+/**
+ * Check if a node is an if/else branch and return the branch key.
+ */
+function getIfElseBranchKey(current, sourceFile) {
+    const parentNode = current.parent;
+    if (!ts.isIfStatement(parentNode))
+        return null;
+    const ifLine = sourceFile.getLineAndCharacterOfPosition(parentNode.getStart()).line;
+    if (current === parentNode.thenStatement)
+        return `if@L${ifLine}`;
+    if (current === parentNode.elseStatement)
+        return `else@L${ifLine}`;
+    return null;
+}
+/**
+ * Check if a node is inside a ternary expression and return the branch key.
+ */
+function getTernaryBranchKey(current, sourceFile) {
+    const parentNode = current.parent;
+    /* v8 ignore next -- defensive AST/type guard */
+    if (!ts.isConditionalExpression(parentNode))
+        return null;
+    const condLine = sourceFile.getLineAndCharacterOfPosition(parentNode.getStart()).line;
+    if (current === parentNode.whenTrue)
+        return `ternary-true@L${condLine}`;
+    if (current === parentNode.whenFalse)
+        return `ternary-false@L${condLine}`;
+    return null;
+}
+/**
+ * Check if a node is a switch case clause and return the branch key.
+ */
+function getSwitchBranchKey(current, sourceFile) {
+    /* v8 ignore next -- defensive AST/type guard */
+    if (!ts.isCaseClause(current) && !ts.isDefaultClause(current))
+        return null;
+    // @fitness-ignore-next-line null-safety -- CaseClause/DefaultClause parent is CaseBlock, grandparent is SwitchStatement per TS AST spec
+    const switchStmt = current.parent.parent;
+    if (!ts.isSwitchStatement(switchStmt))
+        return null;
+    const switchLine = sourceFile.getLineAndCharacterOfPosition(switchStmt.getStart()).line;
+    if (ts.isCaseClause(current)) {
+        const caseText = current.expression.getText(sourceFile);
+        return `case-${caseText}@L${switchLine}`;
+    }
+    return `default@L${switchLine}`;
+}
+/**
+ * Walk up the AST from a node to find if it's inside a conditional branch.
+ * Returns a branch key like 'if@L42' or 'else@L42' to identify which branch,
+ * or null if not inside a conditional branch.
+ *
+ * Starts at the node itself (not node.parent) so that direct children of
+ * ternary expressions are correctly identified as branch members. For example,
+ * in `cond ? await X : await Y`, the AwaitExpression is a direct child of
+ * the ConditionalExpression. Starting at node.parent would skip past the
+ * AwaitExpression level and miss the ternary branch detection.
+ */
+function getBranchKey(node, sourceFile, functionNode) {
+    let current = node;
+    while (current !== functionNode) {
+        const ifElseKey = getIfElseBranchKey(current, sourceFile);
+        if (ifElseKey)
+            return ifElseKey;
+        const ternaryKey = getTernaryBranchKey(current, sourceFile);
+        /* v8 ignore next -- defensive AST/type guard */
+        if (ternaryKey)
+            return ternaryKey;
+        const switchKey = getSwitchBranchKey(current, sourceFile);
+        /* v8 ignore next -- defensive AST/type guard */
+        if (switchKey)
+            return switchKey;
+        current = current.parent;
+    }
+    return null;
+}
+/**
+ * Extract individual binding names from a destructuring pattern.
+ * For `const { foo, bar } = ...` returns ['foo', 'bar'].
+ * For `const [a, b] = ...` returns ['a', 'b'].
+ */
+function extractDestructuredBindings(pattern, sourceFile) {
+    const names = [];
+    // @lazy-ok -- iterating binding elements, not awaiting
+    for (const element of pattern.elements) {
+        if (ts.isBindingElement(element)) {
+            if (ts.isIdentifier(element.name)) {
+                names.push(element.name.getText(sourceFile));
+            }
+            else if (ts.isObjectBindingPattern(element.name) ||
+                ts.isArrayBindingPattern(element.name)) {
+                // Nested destructuring: recurse
+                names.push(...extractDestructuredBindings(element.name, sourceFile));
+            }
+        }
+    }
+    return names;
+}
+/**
+ * Collect all await expressions within an async function (non-recursive into nested async functions)
+ */
+function collectAwaitExpressions(node, sourceFile) {
+    const awaitInfos = [];
+    const visit = (n) => {
+        // Don't recurse into nested async functions
+        if (n !== node && isAsyncFunction(n)) {
+            return;
+        }
+        if (ts.isAwaitExpression(n)) {
+            const { line, character } = sourceFile.getLineAndCharacterOfPosition(n.getStart());
+            const assignedVariable = getAssignedVariable(n, sourceFile);
+            const destructuredBindings = getDestructuredBindings(n, sourceFile);
+            const isDynamicImport = isDynamicImportExpression(n);
+            const branchKey = getBranchKey(n, sourceFile, node);
+            awaitInfos.push({
+                line: line + 1, // Convert to 1-indexed
+                column: character + 1,
+                assignedVariable,
+                destructuredBindings,
+                expressionText: n.getText(sourceFile),
+                isDynamicImport,
+                branchKey,
+                node: n,
+            });
+        }
+        ts.forEachChild(n, visit);
+    };
+    ts.forEachChild(node, visit);
+    return awaitInfos;
+}
+/**
+ * Get the variable name if this await is part of a variable declaration or assignment
+ */
+function getAssignedVariable(awaitNode, sourceFile) {
+    // Check if parent is a variable declaration: const foo = await ...
+    const parent = awaitNode.parent;
+    if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
+        return parent.name.getText(sourceFile);
+    }
+    // Check for destructuring: const { foo } = await ... or const [foo] = await ...
+    if (ts.isVariableDeclaration(parent) &&
+        (ts.isObjectBindingPattern(parent.name) || ts.isArrayBindingPattern(parent.name))) {
+        // Return a placeholder to indicate there's an assigned variable
+        return parent.name.getText(sourceFile);
+    }
+    // Check for assignment: foo = await ...
+    if (ts.isBinaryExpression(parent) &&
+        parent.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+        ts.isIdentifier(parent.left)) {
+        return parent.left.getText(sourceFile);
+    }
+    return null;
+}
+/**
+ * Get individual binding names from destructured await patterns
+ */
+function getDestructuredBindings(awaitNode, sourceFile) {
+    const parent = awaitNode.parent;
+    if (ts.isVariableDeclaration(parent) &&
+        (ts.isObjectBindingPattern(parent.name) || ts.isArrayBindingPattern(parent.name))) {
+        return extractDestructuredBindings(parent.name, sourceFile);
+    }
+    return [];
+}
+/**
+ * Check if an await expression is a dynamic import: `await import('...')`
+ */
+function isDynamicImportExpression(awaitNode) {
+    const expr = awaitNode.expression;
+    // import(...) appears as a CallExpression with an ImportKeyword
+    return ts.isCallExpression(expr) && expr.expression.kind === ts.SyntaxKind.ImportKeyword;
+}
+/**
+ * Check if an await expression calls a sleep/delay function
+ */
+function isSleepOrDelay(expressionText) {
+    const afterAwait = expressionText.replace(/^await\s+/, '');
+    // Extract the function name from patterns like: sleep(100), this.sleep(100), delay(ms)
+    // eslint-disable-next-line sonarjs/slow-regex -- `\w+` bounded by `(`; optional `this.` prefix is fixed
+    const match = /(?:this\.)?(\w+)\s*\(/.exec(afterAwait);
+    if (match?.[1] !== undefined) {
+        return SLEEP_DELAY_NAMES.has(match[1]);
+    }
+    return false;
+}
+/**
+ * Check if an await expression calls a lock/acquire function
+ */
+function isLockAcquire(expressionText) {
+    const afterAwait = expressionText.replace(/^await\s+/, '');
+    // Extract the function name from patterns like: this.acquire(), acquire(timeout)
+    // eslint-disable-next-line sonarjs/slow-regex -- `\w+` bounded by `(`; optional `this.` prefix is fixed
+    const match = /(?:this\.)?(\w+)\s*\(/.exec(afterAwait);
+    if (match?.[1] !== undefined) {
+        return LOCK_ACQUIRE_NAMES.has(match[1]);
+    }
+    return false;
+}
+/**
+ * Check if the next await references any of the destructured bindings from the current await
+ */
+function nextUsesDestructuredBindings(current, next) {
+    if (current.destructuredBindings.length === 0) {
+        return false;
+    }
+    return current.destructuredBindings.some((binding) => next.expressionText.includes(binding));
+}
+/**
+ * Check whether a pair of consecutive await expressions should be skipped (not flagged).
+ * Returns true if the pair is NOT a parallelizable waterfall.
+ */
+function shouldSkipAwaitPair(current, next) {
+    // Skip if awaits are not on consecutive or near-consecutive lines
+    /* v8 ignore next -- defensive AST/type guard */
+    if (next.line - current.line > MAX_LINE_GAP + 1)
+        return true;
+    // Skip if both awaits are in different branches of a conditional
+    if (current.branchKey !== null &&
+        next.branchKey !== null &&
+        // @fitness-ignore-next-line unsafe-secret-comparison -- Comparing AST branch identifiers, not cryptographic keys
+        current.branchKey !== next.branchKey) {
+        return true;
+    }
+    // Skip if either await is a sleep/delay call (inherently sequential in polling loops)
+    /* v8 ignore next -- defensive AST/type guard */
+    if (isSleepOrDelay(current.expressionText) || isSleepOrDelay(next.expressionText))
+        return true;
+    // Skip if the first await is a lock/acquire call (inherently sequential)
+    /* v8 ignore next -- defensive AST/type guard */
+    if (isLockAcquire(current.expressionText))
+        return true;
+    // If the first await has an assigned variable, check if the second await uses it
+    if (current.assignedVariable !== null && next.expressionText.includes(current.assignedVariable)) {
+        return true;
+    }
+    // Check if the first await has destructured bindings used by the second
+    /* v8 ignore next -- defensive AST/type guard */
+    if (nextUsesDestructuredBindings(current, next))
+        return true;
+    // Skip if the first await is a dynamic import (next line typically uses the import)
+    /* v8 ignore next -- defensive AST/type guard */
+    if (current.isDynamicImport)
+        return true;
+    // Skip if either await is not a function call (just awaiting a variable)
+    if (!isAwaitingFunctionCall(current.expressionText) ||
+        !isAwaitingFunctionCall(next.expressionText)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Detect waterfall patterns in a list of await expressions
+ */
+function detectWaterfalls(awaitInfos) {
+    const violations = [];
+    // Sort by line number
+    const sorted = [...awaitInfos].sort((a, b) => a.line - b.line);
+    // @lazy-ok -- validation depends on preceding await result
+    for (let i = 0; i < sorted.length - 1; i++) {
+        const current = sorted[i];
+        const next = sorted[i + 1];
+        // Array access with bounds-checked index is safe here
+        if (current === undefined || next === undefined)
+            continue;
+        if (shouldSkipAwaitPair(current, next))
+            continue;
+        // This looks like a potential waterfall pattern
+        violations.push({
+            line: current.line,
+            column: current.column,
+            message: 'Sequential await statements may be parallelizable with Promise.all()',
+            severity: 'warning',
+            suggestion: 'Consider using Promise.all() to parallelize independent async operations. ' +
+                'Example: const [result1, result2] = await Promise.all([asyncOp1(), asyncOp2()]);',
+            type: 'async-waterfall',
+            match: `${current.expressionText} followed by ${next.expressionText}`,
+        });
+        // Skip the next await since we already flagged this pair
+        i++;
+    }
+    return violations;
+}
+/**
+ * Check if an await expression is awaiting a function call (not just a variable or property)
+ */
+function isAwaitingFunctionCall(expressionText) {
+    // Remove the "await " prefix
+    const afterAwait = expressionText.replace(/^await\s+/, '');
+    // Check if it ends with () or has a call pattern
+    // This catches: foo(), foo.bar(), this.foo(), obj.method(args)
+    // eslint-disable-next-line sonarjs/slow-regex -- [^)]* bounded by ')' delimiter; $ anchored
+    return /\([^)]*\)\s*$/.test(afterAwait);
+}
+/**
+ * Analyze a file for async waterfall patterns
+ */
+function analyzeFile(absolutePath, content) {
+    const violations = [];
+    const sourceFile = getSharedSourceFile(absolutePath, content);
+    /* v8 ignore next -- defensive guard */
+    if (!sourceFile)
+        return [];
+    // Find all async functions and analyze their await expressions
+    const visit = (node) => {
+        if (isAsyncFunction(node)) {
+            const asyncNode = node;
+            const awaitInfos = collectAwaitExpressions(asyncNode, sourceFile);
+            const newViolations = detectWaterfalls(awaitInfos);
+            violations.push(...newViolations);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return violations;
+}
+/**
+ * Check: quality/async-waterfall-detection
+ *
+ * Detects sequential await statements that could potentially be parallelized.
+ * Uses AST-aware heuristics including:
+ * - Consecutive await detection within a configurable line gap
+ * - Variable dependency tracking (simple names and destructured bindings)
+ * - Conditional branch awareness (if/else, ternary, switch/case)
+ * - Dynamic import recognition
+ * - Mutex/lock acquire pattern exclusion
+ * - Sleep/delay pattern exclusion
+ */
+export const asyncWaterfallDetection = defineCheck({
+    id: 'cf169aa8-906c-4e74-bd48-8c9f59ae3eb7',
+    slug: 'async-waterfall-detection',
+    scope: { languages: ['typescript'], concerns: ['backend', 'server'] },
+    contentFilter: 'strip-strings',
+    confidence: 'high',
+    description: 'Detect sequential await statements that could be parallelized',
+    longDescription: `**Purpose:** Detects sequential await statements that could potentially be parallelized with \`Promise.all()\`.
+
+**Detects:** Analyzes each file individually using TypeScript AST. Finds consecutive await expressions (within ${MAX_LINE_GAP + 1} lines) in async functions where the second await does not reference the variable assigned by the first, and both await function calls (matched by trailing parentheses).
+
+**Excludes (not flagged):**
+- Awaits in different conditional branches (if/else, ternary, switch/case)
+- Dynamic \`await import()\` expressions (next statement almost always depends on the import)
+- Destructured binding dependencies (e.g., \`const { x } = await import(...); await x()\`)
+- Sleep/delay calls in polling loops (\`await sleep()\`, \`await delay()\`)
+- Mutex/lock acquire patterns (\`await this.acquire()\`, \`await lock()\`)
+- CLI entry point files (\`**/bin/**\`)
+
+**Why it matters:** Sequential independent awaits double latency unnecessarily; parallelizing them with \`Promise.all()\` can significantly improve performance.
+
+**Scope:** General best practice`,
+    tags: ['quality', 'performance', 'async', 'patterns'],
+    fileTypes: ['ts'],
+    analyze(content, filePath) {
+        // Skip test files — sequential awaits in tests are low-risk
+        if (isTestFile(filePath))
+            return [];
+        // @lazy-ok -- 'await' appears as a string literal, not an actual await expression
+        // Quick filter: skip files without async/await
+        if (!content.includes('await')) {
+            return [];
+        }
+        return analyzeFile(filePath, content);
+    },
+});
+//# sourceMappingURL=async-waterfall-detection.js.map

package/dist/checks/quality/patterns/async-waterfall-detection.js.map

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

package/dist/checks/quality/patterns/dispose-pattern-completeness.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @fileoverview Dispose Pattern Completeness check
+ *
+ * Validates that classes implementing IDisposable properly clean up resources.
+ * Ensures all subscriptions, connections, and resources are disposed.
+ */
+/**
+ * Check: quality/dispose-pattern-completeness
+ *
+ * Validates IDisposable implementations properly clean up resources.
+ */
+export declare const disposePatternCompleteness: import("@opensip-cli/fitness").Check;
+//# sourceMappingURL=dispose-pattern-completeness.d.ts.map

package/dist/checks/quality/patterns/dispose-pattern-completeness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispose-pattern-completeness.d.ts","sourceRoot":"","sources":["../../../../src/checks/quality/patterns/dispose-pattern-completeness.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAsPH;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,sCAiCrC,CAAC"}

package/dist/checks/quality/patterns/dispose-pattern-completeness.js

@@ -0,0 +1,220 @@
+/**
+ * @fileoverview Dispose Pattern Completeness check
+ *
+ * Validates that classes implementing IDisposable properly clean up resources.
+ * Ensures all subscriptions, connections, and resources are disposed.
+ */
+import { defineCheck } from '@opensip-cli/fitness';
+import { getSharedSourceFile } from '@opensip-cli/lang-typescript';
+import * as ts from 'typescript';
+/**
+ * Check if a class implements IDisposable or Disposable
+ * @param node - The class declaration node
+ * @returns True if class implements IDisposable
+ */
+function classImplementsDisposable(node) {
+    if (!node.heritageClauses) {
+        return false;
+    }
+    return node.heritageClauses.some((clause) => {
+        // @fitness-ignore-next-line unsafe-secret-comparison -- Comparing TypeScript AST syntax kind token, not a cryptographic token
+        if (clause.token !== ts.SyntaxKind.ImplementsKeyword) {
+            return false;
+        }
+        return clause.types.some((type) => ts.isIdentifier(type.expression) &&
+            (type.expression.text === 'IDisposable' || type.expression.text === 'Disposable'));
+    });
+}
+/**
+ * Find the dispose method in a class
+ * @param node - The class declaration node
+ * @returns The dispose method or undefined
+ */
+function findDisposeMethod(node) {
+    const member = node.members.find((m) => ts.isMethodDeclaration(m) && ts.isIdentifier(m.name) && m.name.text === 'dispose');
+    return member;
+}
+/**
+ * Create a violation for missing dispose method
+ * @param ctx - Violation context
+ * @param node - The class declaration node
+ * @param className - The class name
+ * @returns CheckViolation object
+ */
+function createMissingDisposeViolation(ctx, node, className) {
+    const { line: lineIdx, character } = ctx.sourceFile.getLineAndCharacterOfPosition(node.getStart());
+    const line = lineIdx + 1;
+    return {
+        line,
+        column: character + 1,
+        message: `Class '${className}' implements IDisposable but has no dispose method`,
+        severity: 'error',
+        suggestion: `Add 'dispose(): void { /* cleanup subscriptions, connections, timers */ }' method to ${className}`,
+        type: 'missing-dispose',
+        match: className,
+    };
+}
+/**
+ * Create a violation for empty dispose method
+ * @param ctx - Violation context
+ * @param disposeMethod - The dispose method node
+ * @param className - The class name
+ * @returns CheckViolation object
+ */
+function createEmptyDisposeViolation(ctx, disposeMethod, className) {
+    const { line: lineIdx, character } = ctx.sourceFile.getLineAndCharacterOfPosition(disposeMethod.getStart());
+    const line = lineIdx + 1;
+    return {
+        line,
+        column: character + 1,
+        message: `Class '${className}' has empty dispose method`,
+        severity: 'warning',
+        suggestion: `Add cleanup logic to dispose(): unsubscribe from subscriptions, close connections, clear timers`,
+        type: 'empty-dispose',
+        match: `${className}.dispose`,
+    };
+}
+/**
+ * Check if dispose method is empty
+ * @param disposeMethod - The dispose method node
+ * @returns True if the dispose method body is empty
+ */
+function isDisposeMethodEmpty(disposeMethod) {
+    const methodBody = disposeMethod.body;
+    return Boolean(methodBody && ts.isBlock(methodBody) && methodBody.statements.length === 0);
+}
+/**
+ * Check if a property is a subscription or listener field
+ * @param member - The class member node
+ * @returns True if the property is a subscription field
+ */
+function isSubscriptionField(member) {
+    if (!ts.isPropertyDeclaration(member) || !ts.isIdentifier(member.name)) {
+        return false;
+    }
+    const nameLower = member.name.text.toLowerCase();
+    return nameLower.includes('subscription') || nameLower.includes('listener');
+}
+/**
+ * Create a violation for uncleaned subscription
+ * @param ctx - Violation context
+ * @param field - The property declaration node
+ * @param fieldName - The field name
+ * @returns CheckViolation object
+ */
+function createUncleanedSubscriptionViolation(ctx, field, fieldName) {
+    const { line: lineIdx, character } = ctx.sourceFile.getLineAndCharacterOfPosition(field.getStart());
+    const line = lineIdx + 1;
+    return {
+        line,
+        column: character + 1,
+        message: `Subscription '${fieldName}' not cleaned up in dispose()`,
+        severity: 'warning',
+        suggestion: `Add 'this.${fieldName}?.unsubscribe();' or 'this.${fieldName} = null;' in the dispose() method`,
+        type: 'uncleaned-subscription',
+        match: fieldName,
+    };
+}
+/**
+ * Check subscription fields for proper cleanup in dispose method
+ * @param ctx - Violation context
+ * @param node - The class declaration node
+ * @param disposeMethod - The dispose method node
+ * @returns Array of violations
+ */
+function checkSubscriptionFields(ctx, node, disposeMethod) {
+    const violations = [];
+    /* v8 ignore next -- defensive nullish fallback */
+    const disposeBody = disposeMethod.body?.getText(ctx.sourceFile) ?? '';
+    for (const member of node.members) {
+        if (!isSubscriptionField(member)) {
+            continue;
+        }
+        const fieldName = member.name.text;
+        if (!disposeBody.includes(fieldName)) {
+            violations.push(createUncleanedSubscriptionViolation(ctx, member, fieldName));
+        }
+    }
+    return violations;
+}
+/**
+ * Analyze a class declaration for dispose pattern issues
+ * @param ctx - Violation context
+ * @param node - The class declaration node
+ * @returns Array of violations
+ */
+function analyzeClassDeclaration(ctx, node) {
+    const violations = [];
+    if (!node.name || !classImplementsDisposable(node)) {
+        return violations;
+    }
+    const className = node.name.text;
+    const disposeMethod = findDisposeMethod(node);
+    if (!disposeMethod) {
+        violations.push(createMissingDisposeViolation(ctx, node, className));
+        return violations;
+    }
+    if (isDisposeMethodEmpty(disposeMethod)) {
+        violations.push(createEmptyDisposeViolation(ctx, disposeMethod, className));
+    }
+    violations.push(...checkSubscriptionFields(ctx, node, disposeMethod));
+    return violations;
+}
+/**
+ * Analyze a file for dispose pattern completeness
+ * @param absolutePath - The file path
+ * @param content - The file content
+ * @returns Array of violations
+ */
+function analyzeFile(absolutePath, content) {
+    const violations = [];
+    const sourceFile = getSharedSourceFile(absolutePath, content);
+    /* v8 ignore next -- defensive guard */
+    if (!sourceFile)
+        return [];
+    const ctx = { absolutePath, content, sourceFile };
+    const visit = (node) => {
+        if (ts.isClassDeclaration(node)) {
+            violations.push(...analyzeClassDeclaration(ctx, node));
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return violations;
+}
+/**
+ * Check: quality/dispose-pattern-completeness
+ *
+ * Validates IDisposable implementations properly clean up resources.
+ */
+export const disposePatternCompleteness = defineCheck({
+    id: 'f4b1e176-e276-45d5-8d75-c132d5b893d4',
+    slug: 'dispose-pattern-completeness',
+    scope: { languages: ['typescript'], concerns: ['backend', 'server'] },
+    confidence: 'high',
+    description: 'Validate IDisposable implementations clean up all resources',
+    longDescription: `**Purpose:** Validates that classes implementing \`IDisposable\` or \`Disposable\` properly clean up all resources in their \`dispose()\` method.
+
+**Detects:** Analyzes each file individually using TypeScript AST. Checks for:
+- Classes implementing IDisposable/Disposable that have no \`dispose()\` method
+- Classes with an empty \`dispose()\` method body
+- Subscription/listener fields (properties containing "subscription" or "listener" in name) not referenced in the \`dispose()\` method body
+
+**Why it matters:** Incomplete dispose implementations cause memory leaks, dangling subscriptions, and unclosed connections that degrade application stability over time.
+
+**Scope:** General best practice`,
+    tags: ['quality', 'resources', 'memory', 'dispose', 'cleanup'],
+    fileTypes: ['ts'],
+    analyze(content, filePath) {
+        // Quick filter: skip files without dispose-related patterns
+        const hasDisposePatterns = content.includes('dispose') ||
+            content.includes('Disposable') ||
+            content.includes('subscription') ||
+            content.includes('unsubscribe');
+        if (!hasDisposePatterns) {
+            return [];
+        }
+        return analyzeFile(filePath, content);
+    },
+});
+//# sourceMappingURL=dispose-pattern-completeness.js.map