pi-lens 2.0.37 → 2.0.39

package/clients/biome-client.ts

@@ -92,14 +92,26 @@ export class BiomeClient {
 		].includes(ext);
 	}
 
+	// --- Internal helpers ---
+
 	/**
-	 * Run biome check (format + lint) without fixing — returns diagnostics
+	 * Validate path and availability — returns path or null on failure
 	 */
-	checkFile(filePath: string): BiomeDiagnostic[] {
-		if (!this.isAvailable()) return [];
+	private withValidatedPath(filePath: string): string | null {
+		if (!this.isAvailable()) return null;
 
 		const absolutePath = path.resolve(filePath);
-		if (!fs.existsSync(absolutePath)) return [];
+		if (!fs.existsSync(absolutePath)) return null;
+
+		return absolutePath;
+	}
+
+	/**
+	 * Run biome check (format + lint) without fixing — returns diagnostics
+	 */
+	checkFile(filePath: string): BiomeDiagnostic[] {
+		const absolutePath = this.withValidatedPath(filePath);
+		if (!absolutePath) return [];
 
 		try {
 			const result = spawnSync(
@@ -137,12 +149,13 @@ export class BiomeClient {
 		changed: boolean;
 		error?: string;
 	} {
-		if (!this.isAvailable())
-			return { success: false, changed: false, error: "Biome not available" };
-
-		const absolutePath = path.resolve(filePath);
-		if (!fs.existsSync(absolutePath))
-			return { success: false, changed: false, error: "File not found" };
+		const absolutePath = this.withValidatedPath(filePath);
+		if (!absolutePath)
+			return {
+				success: false,
+				changed: false,
+				error: this.isAvailable() ? "File not found" : "Biome not available",
+			};
 
 		const content = fs.readFileSync(absolutePath, "utf-8");
 
@@ -184,21 +197,13 @@ export class BiomeClient {
 		fixed: number;
 		error?: string;
 	} {
-		if (!this.isAvailable())
-			return {
-				success: false,
-				changed: false,
-				fixed: 0,
-				error: "Biome not available",
-			};
-
-		const absolutePath = path.resolve(filePath);
-		if (!fs.existsSync(absolutePath))
+		const absolutePath = this.withValidatedPath(filePath);
+		if (!absolutePath)
 			return {
 				success: false,
 				changed: false,
 				fixed: 0,
-				error: "File not found",
+				error: this.isAvailable() ? "File not found" : "Biome not available",
 			};
 
 		const content = fs.readFileSync(absolutePath, "utf-8");
@@ -288,10 +293,8 @@ export class BiomeClient {
 	 * Generate a diff-like summary of formatting changes
 	 */
 	getFormatDiff(filePath: string): string {
-		if (!this.isAvailable()) return "";
-
-		const absolutePath = path.resolve(filePath);
-		if (!fs.existsSync(absolutePath)) return "";
+		const absolutePath = this.withValidatedPath(filePath);
+		if (!absolutePath) return "";
 
 		const content = fs.readFileSync(absolutePath, "utf-8");
 

package/clients/complexity-client.js

@@ -126,70 +126,88 @@ export class ComplexityClient {
      * Analyze complexity metrics for a file
      */
     analyzeFile(filePath) {
-        const absolutePath = path.resolve(filePath);
-        if (!fs.existsSync(absolutePath))
+        const parsed = this.readAndParse(filePath);
+        if (!parsed)
             return null;
         try {
-            const content = fs.readFileSync(absolutePath, "utf-8");
-            const lines = content.split("\n");
-            const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
-            // Count lines of code (non-empty, non-comment)
-            const { codeLines, commentLines } = this.countLines(sourceFile, lines);
-            // Collect function metrics
-            const functions = [];
-            this.collectFunctionMetrics(sourceFile, sourceFile, functions, 0);
-            // Calculate file-level metrics
-            const maxNestingDepth = this.calculateMaxNesting(sourceFile, 0);
-            const _cyclomatic = this.calculateCyclomaticComplexity(sourceFile);
-            const cognitive = this.calculateCognitiveComplexity(sourceFile);
-            const halstead = this.calculateHalsteadVolume(sourceFile);
-            // Function length stats
-            const funcLengths = functions.map((f) => f.length);
-            const avgFunctionLength = funcLengths.length > 0
-                ? Math.round(funcLengths.reduce((a, b) => a + b, 0) / funcLengths.length)
-                : 0;
-            const maxFunctionLength = funcLengths.length > 0 ? Math.max(...funcLengths) : 0;
-            // Function cyclomatic stats
-            const cyclomatics = functions.map((f) => f.cyclomatic);
-            const avgCyclomatic = cyclomatics.length > 0
-                ? Math.round(cyclomatics.reduce((a, b) => a + b, 0) / cyclomatics.length)
-                : 1;
-            const maxCyclomatic = cyclomatics.length > 0 ? Math.max(...cyclomatics) : 1;
-            // Maintainability Index (simplified Microsoft formula)
-            // MI = max(0, (171 - 5.2 * ln(Halstead) - 0.23 * Cyclomatic - 16.2 * ln(LOC)) * 100 / 171)
-            const maintainabilityIndex = this.calculateMaintainabilityIndex(halstead, avgCyclomatic, codeLines, commentLines);
-            // Code Entropy (Shannon entropy of code tokens)
-            const codeEntropy = this.calculateCodeEntropy(content);
-            // AI slop indicators
-            const maxParamsInFunction = this.calculateMaxParams(functions);
-            const aiCommentPatterns = this.countAICommentPatterns(sourceFile);
-            const singleUseFunctions = this.countSingleUseFunctions(functions);
-            const tryCatchCount = this.countTryCatch(sourceFile);
-            return {
-                filePath: path.relative(process.cwd(), absolutePath),
-                maxNestingDepth,
-                avgFunctionLength,
-                maxFunctionLength,
-                functionCount: functions.length,
-                cyclomaticComplexity: avgCyclomatic,
-                maxCyclomaticComplexity: maxCyclomatic,
-                cognitiveComplexity: cognitive,
-                halsteadVolume: Math.round(halstead * 10) / 10,
-                maintainabilityIndex: Math.round(maintainabilityIndex * 10) / 10,
-                linesOfCode: codeLines,
-                commentLines,
-                codeEntropy: Math.round(codeEntropy * 100) / 100,
-                maxParamsInFunction,
-                aiCommentPatterns,
-                singleUseFunctions,
-                tryCatchCount,
-            };
+            return this.computeMetrics(parsed);
         }
         catch (err) {
             this.log(`Analysis error for ${filePath}: ${err.message}`);
             return null;
         }
     }
+    /**
+     * Read file and parse to TypeScript AST
+     */
+    readAndParse(filePath) {
+        const absolutePath = path.resolve(filePath);
+        if (!fs.existsSync(absolutePath))
+            return null;
+        const content = fs.readFileSync(absolutePath, "utf-8");
+        const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+        return { absolutePath, content, sourceFile };
+    }
+    /**
+     * Compute all metrics from parsed source
+     */
+    computeMetrics(parsed) {
+        const { absolutePath, content, sourceFile } = parsed;
+        const lines = content.split("\n");
+        // Line counts and function collection
+        const { codeLines, commentLines } = this.countLines(sourceFile, lines);
+        const functions = this.collectFunctionMetrics(sourceFile);
+        // File-level complexity metrics
+        const maxNestingDepth = this.calculateMaxNesting(sourceFile, 0);
+        const cognitive = this.calculateCognitiveComplexity(sourceFile);
+        const halstead = this.calculateHalsteadVolume(sourceFile);
+        // Aggregate function statistics
+        const funcStats = this.aggregateFunctionStats(functions);
+        // Derived metrics
+        const maintainabilityIndex = this.calculateMaintainabilityIndex(halstead, funcStats.avgCyclomatic, codeLines, commentLines);
+        const codeEntropy = this.calculateCodeEntropy(content);
+        // AI slop indicators
+        const maxParamsInFunction = this.calculateMaxParams(functions);
+        const aiCommentPatterns = this.countAICommentPatterns(sourceFile);
+        const singleUseFunctions = this.countSingleUseFunctions(functions);
+        const tryCatchCount = this.countTryCatch(sourceFile);
+        return {
+            filePath: path.relative(process.cwd(), absolutePath),
+            maxNestingDepth,
+            avgFunctionLength: funcStats.avgLength,
+            maxFunctionLength: funcStats.maxLength,
+            functionCount: functions.length,
+            cyclomaticComplexity: funcStats.avgCyclomatic,
+            maxCyclomaticComplexity: funcStats.maxCyclomatic,
+            cognitiveComplexity: cognitive,
+            halsteadVolume: Math.round(halstead * 10) / 10,
+            maintainabilityIndex: Math.round(maintainabilityIndex * 10) / 10,
+            linesOfCode: codeLines,
+            commentLines,
+            codeEntropy: Math.round(codeEntropy * 100) / 100,
+            maxParamsInFunction,
+            aiCommentPatterns,
+            singleUseFunctions,
+            tryCatchCount,
+        };
+    }
+    /**
+     * Aggregate function metrics into summary statistics
+     */
+    aggregateFunctionStats(functions) {
+        if (functions.length === 0) {
+            return { avgLength: 0, maxLength: 0, avgCyclomatic: 1, maxCyclomatic: 1 };
+        }
+        const lengths = functions.map((f) => f.length);
+        const cyclomatics = functions.map((f) => f.cyclomatic);
+        const sum = (arr) => arr.reduce((a, b) => a + b, 0);
+        return {
+            avgLength: Math.round(sum(lengths) / lengths.length),
+            maxLength: Math.max(...lengths),
+            avgCyclomatic: Math.max(1, Math.round(sum(cyclomatics) / cyclomatics.length)),
+            maxCyclomatic: Math.max(1, Math.max(...cyclomatics)),
+        };
+    }
     /**
      * Format metrics for display
      */
@@ -316,9 +334,9 @@ export class ComplexityClient {
         if (metrics.codeEntropy > 3.5) {
             warnings.push(`High entropy (${metrics.codeEntropy.toFixed(1)} bits) — follow project conventions`);
         }
-        // Comments ratio (>30% = excessive comments, AI slop signal)
+        // Comments ratio (>40% = excessive comments, AI slop signal)
         const totalLines = metrics.linesOfCode + metrics.commentLines;
-        if (totalLines > 10 && metrics.commentLines / totalLines > 0.3) {
+        if (totalLines > 10 && metrics.commentLines / totalLines > 0.4) {
             warnings.push(`Excessive comments (${Math.round((metrics.commentLines / totalLines) * 100)}%) — remove obvious comments`);
         }
         // Verbose code (long functions with low complexity = overly verbose)
@@ -330,7 +348,7 @@ export class ComplexityClient {
             warnings.push(`AI-style comments (${metrics.aiCommentPatterns}) — remove hand-holding comments`);
         }
         // AI slop: Too many try/catch blocks (lazy error handling)
-        if (metrics.tryCatchCount > 5) {
+        if (metrics.tryCatchCount > 15) {
             warnings.push(`Many try/catch blocks (${metrics.tryCatchCount}) — consolidate error handling`);
         }
         // AI slop: Over-abstraction (many single-use helper functions)
@@ -385,12 +403,31 @@ export class ComplexityClient {
         commentLines = commentPositions.size;
         const codeLines = lines.filter((line, i) => {
             const trimmed = line.trim();
-            return trimmed.length > 0 && !commentPositions.has(i);
+            if (trimmed.length === 0)
+                return false;
+            // If the line is not in commentPositions, it definitely has code
+            if (!commentPositions.has(i))
+                return true;
+            // If it IS in commentPositions, it might still have code (trailing comment)
+            // Remove the comment part and check if anything remains
+            const lineWithoutComments = line
+                .replace(/\/\/.*$/, "")
+                .replace(/\/\*[\s\S]*?\*\//g, "")
+                .trim();
+            return lineWithoutComments.length > 0;
         }).length;
         return { codeLines, commentLines };
     }
     // --- Private: Function Metrics Collection ---
-    collectFunctionMetrics(node, sourceFile, functions, nestingLevel) {
+    /**
+     * Collect metrics for all functions in the source file
+     */
+    collectFunctionMetrics(sourceFile) {
+        const functions = [];
+        this.visitFunctionMetrics(sourceFile, sourceFile, functions, 0);
+        return functions;
+    }
+    visitFunctionMetrics(node, sourceFile, functions, nestingLevel) {
         if (FUNCTION_LIKE_NODES.has(node.kind)) {
             const funcNode = node;
             const startLine = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line;
@@ -416,7 +453,7 @@ export class ComplexityClient {
             ? nestingLevel + 1
             : nestingLevel;
         ts.forEachChild(node, (child) => {
-            this.collectFunctionMetrics(child, sourceFile, functions, newNesting);
+            this.visitFunctionMetrics(child, sourceFile, functions, newNesting);
         });
     }
     // --- Private: Max Nesting Depth ---
@@ -436,18 +473,22 @@ export class ComplexityClient {
     calculateCyclomaticComplexity(node) {
         return this.nodeCyclomaticComplexity(node, 0);
     }
+    isLogicalOperator(node) {
+        if (node.kind === ts.SyntaxKind.BinaryExpression) {
+            const binary = node;
+            return (binary.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken ||
+                binary.operatorToken.kind === ts.SyntaxKind.BarBarToken);
+        }
+        return false;
+    }
     nodeCyclomaticComplexity(node, complexity) {
         // Base increment for branching nodes
         if (CYCLOMAL_NODES.has(node.kind)) {
             complexity++;
         }
         // Binary && and || add complexity
-        if (node.kind === ts.SyntaxKind.BinaryExpression) {
-            const binary = node;
-            if (binary.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken ||
-                binary.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
-                complexity++;
-            }
+        if (this.isLogicalOperator(node)) {
+            complexity++;
         }
         ts.forEachChild(node, (child) => {
             complexity = this.nodeCyclomaticComplexity(child, complexity);
@@ -475,12 +516,8 @@ export class ComplexityClient {
             }
         }
         // Binary && and || contribute to complexity
-        if (node.kind === ts.SyntaxKind.BinaryExpression) {
-            const binary = node;
-            if (binary.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken ||
-                binary.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
-                complexity += 1;
-            }
+        if (this.isLogicalOperator(node)) {
+            complexity += 1;
         }
         // Calculate nesting for children
         const increasesNesting = NESTING_NODES.has(node.kind);

package/clients/complexity-client.ts

@@ -171,97 +171,122 @@ export class ComplexityClient {
 	 * Analyze complexity metrics for a file
 	 */
 	analyzeFile(filePath: string): FileComplexity | null {
-		const absolutePath = path.resolve(filePath);
-		if (!fs.existsSync(absolutePath)) return null;
+		const parsed = this.readAndParse(filePath);
+		if (!parsed) return null;
 
 		try {
-			const content = fs.readFileSync(absolutePath, "utf-8");
-			const lines = content.split("\n");
-			const sourceFile = ts.createSourceFile(
-				filePath,
-				content,
-				ts.ScriptTarget.Latest,
-				true,
-			);
-
-			// Count lines of code (non-empty, non-comment)
-			const { codeLines, commentLines } = this.countLines(sourceFile, lines);
-
-			// Collect function metrics
-			const functions: FunctionMetrics[] = [];
-			this.collectFunctionMetrics(sourceFile, sourceFile, functions, 0);
-
-			// Calculate file-level metrics
-			const maxNestingDepth = this.calculateMaxNesting(sourceFile, 0);
-			const _cyclomatic = this.calculateCyclomaticComplexity(sourceFile);
-			const cognitive = this.calculateCognitiveComplexity(sourceFile);
-			const halstead = this.calculateHalsteadVolume(sourceFile);
-
-			// Function length stats
-			const funcLengths = functions.map((f) => f.length);
-			const avgFunctionLength =
-				funcLengths.length > 0
-					? Math.round(
-							funcLengths.reduce((a, b) => a + b, 0) / funcLengths.length,
-						)
-					: 0;
-			const maxFunctionLength =
-				funcLengths.length > 0 ? Math.max(...funcLengths) : 0;
-
-			// Function cyclomatic stats
-			const cyclomatics = functions.map((f) => f.cyclomatic);
-			const avgCyclomatic =
-				cyclomatics.length > 0
-					? Math.round(
-							cyclomatics.reduce((a, b) => a + b, 0) / cyclomatics.length,
-						)
-					: 1;
-			const maxCyclomatic =
-				cyclomatics.length > 0 ? Math.max(...cyclomatics) : 1;
-
-			// Maintainability Index (simplified Microsoft formula)
-			// MI = max(0, (171 - 5.2 * ln(Halstead) - 0.23 * Cyclomatic - 16.2 * ln(LOC)) * 100 / 171)
-			const maintainabilityIndex = this.calculateMaintainabilityIndex(
-				halstead,
-				avgCyclomatic,
-				codeLines,
-				commentLines,
-			);
-
-			// Code Entropy (Shannon entropy of code tokens)
-			const codeEntropy = this.calculateCodeEntropy(content);
-
-			// AI slop indicators
-			const maxParamsInFunction = this.calculateMaxParams(functions);
-			const aiCommentPatterns = this.countAICommentPatterns(sourceFile);
-			const singleUseFunctions = this.countSingleUseFunctions(functions);
-			const tryCatchCount = this.countTryCatch(sourceFile);
-
-			return {
-				filePath: path.relative(process.cwd(), absolutePath),
-				maxNestingDepth,
-				avgFunctionLength,
-				maxFunctionLength,
-				functionCount: functions.length,
-				cyclomaticComplexity: avgCyclomatic,
-				maxCyclomaticComplexity: maxCyclomatic,
-				cognitiveComplexity: cognitive,
-				halsteadVolume: Math.round(halstead * 10) / 10,
-				maintainabilityIndex: Math.round(maintainabilityIndex * 10) / 10,
-				linesOfCode: codeLines,
-				commentLines,
-				codeEntropy: Math.round(codeEntropy * 100) / 100,
-				maxParamsInFunction,
-				aiCommentPatterns,
-				singleUseFunctions,
-				tryCatchCount,
-			};
+			return this.computeMetrics(parsed);
 		} catch (err: any) {
 			this.log(`Analysis error for ${filePath}: ${err.message}`);
 			return null;
 		}
 	}
 
+	/**
+	 * Read file and parse to TypeScript AST
+	 */
+	private readAndParse(
+		filePath: string,
+	): { absolutePath: string; content: string; sourceFile: ts.SourceFile } | null {
+		const absolutePath = path.resolve(filePath);
+		if (!fs.existsSync(absolutePath)) return null;
+
+		const content = fs.readFileSync(absolutePath, "utf-8");
+		const sourceFile = ts.createSourceFile(
+			filePath,
+			content,
+			ts.ScriptTarget.Latest,
+			true,
+		);
+
+		return { absolutePath, content, sourceFile };
+	}
+
+	/**
+	 * Compute all metrics from parsed source
+	 */
+	private computeMetrics(parsed: {
+		absolutePath: string;
+		content: string;
+		sourceFile: ts.SourceFile;
+	}): FileComplexity {
+		const { absolutePath, content, sourceFile } = parsed;
+		const lines = content.split("\n");
+
+		// Line counts and function collection
+		const { codeLines, commentLines } = this.countLines(sourceFile, lines);
+		const functions = this.collectFunctionMetrics(sourceFile);
+
+		// File-level complexity metrics
+		const maxNestingDepth = this.calculateMaxNesting(sourceFile, 0);
+		const cognitive = this.calculateCognitiveComplexity(sourceFile);
+		const halstead = this.calculateHalsteadVolume(sourceFile);
+
+		// Aggregate function statistics
+		const funcStats = this.aggregateFunctionStats(functions);
+
+		// Derived metrics
+		const maintainabilityIndex = this.calculateMaintainabilityIndex(
+			halstead,
+			funcStats.avgCyclomatic,
+			codeLines,
+			commentLines,
+		);
+		const codeEntropy = this.calculateCodeEntropy(content);
+
+		// AI slop indicators
+		const maxParamsInFunction = this.calculateMaxParams(functions);
+		const aiCommentPatterns = this.countAICommentPatterns(sourceFile);
+		const singleUseFunctions = this.countSingleUseFunctions(functions);
+		const tryCatchCount = this.countTryCatch(sourceFile);
+
+		return {
+			filePath: path.relative(process.cwd(), absolutePath),
+			maxNestingDepth,
+			avgFunctionLength: funcStats.avgLength,
+			maxFunctionLength: funcStats.maxLength,
+			functionCount: functions.length,
+			cyclomaticComplexity: funcStats.avgCyclomatic,
+			maxCyclomaticComplexity: funcStats.maxCyclomatic,
+			cognitiveComplexity: cognitive,
+			halsteadVolume: Math.round(halstead * 10) / 10,
+			maintainabilityIndex: Math.round(maintainabilityIndex * 10) / 10,
+			linesOfCode: codeLines,
+			commentLines,
+			codeEntropy: Math.round(codeEntropy * 100) / 100,
+			maxParamsInFunction,
+			aiCommentPatterns,
+			singleUseFunctions,
+			tryCatchCount,
+		};
+	}
+
+	/**
+	 * Aggregate function metrics into summary statistics
+	 */
+	private aggregateFunctionStats(functions: FunctionMetrics[]): {
+		avgLength: number;
+		maxLength: number;
+		avgCyclomatic: number;
+		maxCyclomatic: number;
+	} {
+		if (functions.length === 0) {
+			return { avgLength: 0, maxLength: 0, avgCyclomatic: 1, maxCyclomatic: 1 };
+		}
+
+		const lengths = functions.map((f) => f.length);
+		const cyclomatics = functions.map((f) => f.cyclomatic);
+
+		const sum = (arr: number[]) => arr.reduce((a, b) => a + b, 0);
+
+		return {
+			avgLength: Math.round(sum(lengths) / lengths.length),
+			maxLength: Math.max(...lengths),
+			avgCyclomatic: Math.max(1, Math.round(sum(cyclomatics) / cyclomatics.length)),
+			maxCyclomatic: Math.max(1, Math.max(...cyclomatics)),
+		};
+	}
+
 	/**
 	 * Format metrics for display
 	 */
@@ -451,9 +476,9 @@ export class ComplexityClient {
 			);
 		}
 
-		// Comments ratio (>30% = excessive comments, AI slop signal)
+		// Comments ratio (>40% = excessive comments, AI slop signal)
 		const totalLines = metrics.linesOfCode + metrics.commentLines;
-		if (totalLines > 10 && metrics.commentLines / totalLines > 0.3) {
+		if (totalLines > 10 && metrics.commentLines / totalLines > 0.4) {
 			warnings.push(
 				`Excessive comments (${Math.round((metrics.commentLines / totalLines) * 100)}%) — remove obvious comments`,
 			);
@@ -474,7 +499,7 @@ export class ComplexityClient {
 		}
 
 		// AI slop: Too many try/catch blocks (lazy error handling)
-		if (metrics.tryCatchCount > 5) {
+		if (metrics.tryCatchCount > 15) {
 			warnings.push(
 				`Many try/catch blocks (${metrics.tryCatchCount}) — consolidate error handling`,
 			);
@@ -556,7 +581,18 @@ export class ComplexityClient {
 		commentLines = commentPositions.size;
 		const codeLines = lines.filter((line, i) => {
 			const trimmed = line.trim();
-			return trimmed.length > 0 && !commentPositions.has(i);
+			if (trimmed.length === 0) return false;
+
+			// If the line is not in commentPositions, it definitely has code
+			if (!commentPositions.has(i)) return true;
+
+			// If it IS in commentPositions, it might still have code (trailing comment)
+			// Remove the comment part and check if anything remains
+			const lineWithoutComments = line
+				.replace(/\/\/.*$/, "")
+				.replace(/\/\*[\s\S]*?\*\//g, "")
+				.trim();
+			return lineWithoutComments.length > 0;
 		}).length;
 
 		return { codeLines, commentLines };
@@ -564,7 +600,16 @@ export class ComplexityClient {
 
 	// --- Private: Function Metrics Collection ---
 
-	private collectFunctionMetrics(
+	/**
+	 * Collect metrics for all functions in the source file
+	 */
+	private collectFunctionMetrics(sourceFile: ts.SourceFile): FunctionMetrics[] {
+		const functions: FunctionMetrics[] = [];
+		this.visitFunctionMetrics(sourceFile, sourceFile, functions, 0);
+		return functions;
+	}
+
+	private visitFunctionMetrics(
 		node: ts.Node,
 		sourceFile: ts.SourceFile,
 		functions: FunctionMetrics[],
@@ -603,7 +648,7 @@ export class ComplexityClient {
 			? nestingLevel + 1
 			: nestingLevel;
 		ts.forEachChild(node, (child) => {
-			this.collectFunctionMetrics(child, sourceFile, functions, newNesting);
+			this.visitFunctionMetrics(child, sourceFile, functions, newNesting);
 		});
 	}
 
@@ -631,6 +676,17 @@ export class ComplexityClient {
 		return this.nodeCyclomaticComplexity(node, 0);
 	}
 
+	private isLogicalOperator(node: ts.Node): boolean {
+		if (node.kind === ts.SyntaxKind.BinaryExpression) {
+			const binary = node as ts.BinaryExpression;
+			return (
+				binary.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken ||
+				binary.operatorToken.kind === ts.SyntaxKind.BarBarToken
+			);
+		}
+		return false;
+	}
+
 	private nodeCyclomaticComplexity(node: ts.Node, complexity: number): number {
 		// Base increment for branching nodes
 		if (CYCLOMAL_NODES.has(node.kind)) {
@@ -638,14 +694,8 @@ export class ComplexityClient {
 		}
 
 		// Binary && and || add complexity
-		if (node.kind === ts.SyntaxKind.BinaryExpression) {
-			const binary = node as ts.BinaryExpression;
-			if (
-				binary.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken ||
-				binary.operatorToken.kind === ts.SyntaxKind.BarBarToken
-			) {
-				complexity++;
-			}
+		if (this.isLogicalOperator(node)) {
+			complexity++;
 		}
 
 		ts.forEachChild(node, (child) => {
@@ -681,14 +731,8 @@ export class ComplexityClient {
 		}
 
 		// Binary && and || contribute to complexity
-		if (node.kind === ts.SyntaxKind.BinaryExpression) {
-			const binary = node as ts.BinaryExpression;
-			if (
-				binary.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken ||
-				binary.operatorToken.kind === ts.SyntaxKind.BarBarToken
-			) {
-				complexity += 1;
-			}
+		if (this.isLogicalOperator(node)) {
+			complexity += 1;
 		}
 
 		// Calculate nesting for children