pi-lens 1.3.13 → 2.0.0

package/CHANGELOG.md

@@ -2,7 +2,33 @@
 
 All notable changes to pi-lens will be documented in this file.
 
-## [1.3.11] - 2026-03-25
+## [2.0.0] - 2026-03-25
+
+### Added
+- **`/lens-metrics` command**: Measure complexity metrics for all files. Exports a full `report.md` with A-F grades, summary stats, AI slop aggregate table, and top 10 worst files with actionable warnings.
+- **`/lens-booboo` saves full report**: Results saved to `.pi-lens/reviews/booboo-<timestamp>.md` — no truncation, all issues, agent-readable.
+- **AI slop indicators**: Four new real-time and report-based detectors:
+  - `AI-style comments` — emoji and boilerplate comment phrases
+  - `Many try/catch blocks` — lazy error handling pattern
+  - `Over-abstraction` — single-use helper functions
+  - `Long parameter list` — functions with > 6 params
+- **`SubprocessClient` base class**: Shared foundation for CLI tool clients (availability check, logging, command execution).
+- **Shared test utilities**: `createTempFile` and `setupTestEnvironment` extracted to `clients/test-utils.ts`, eliminating copy-paste across 13 test files.
+
+### Changed
+- **Delta mode for real-time feedback**: ast-grep and Biome now only show *new* violations introduced by the current edit — not all pre-existing ones. Fixed violations shown as `✓ Fixed: rule-name (-N)`. No change = silent.
+- **Removed redundant pre-write hints**: ast-grep and Biome pre-write counts removed (delta mode makes them obsolete). TypeScript pre-write warning kept (blocking errors).
+- **Test files excluded from AI slop warnings**: MI/complexity thresholds are inherently low in test files — warnings suppressed for `*.test.ts` / `*.spec.ts`.
+- **Test files excluded from TODO scanner**: Test fixture annotations (`FIXME`, `BUG`, etc.) no longer appear in TODO reports.
+- **ast-grep excludes test files and `.pi-lens/`**: Design smell scan in `/lens-booboo` skips test files (no magic-numbers noise) and internal review reports.
+- **jscpd excludes non-code files**: `.md`, `.json`, `.yaml`, `.yml`, `.toml`, `.lock`, and `.pi-lens/` excluded from duplicate detection — no more false positives from report files.
+- **Removed unused dependencies**: `vscode-languageserver-protocol` and `vscode-languageserver-types` removed; `@sinclair/typebox` added (was unlisted).
+
+### Fixed
+- Removed 3 unconditional `console.log` calls leaking `[scan_exports]` to terminal.
+- Duplicate Biome scan in `tool_call` hook eliminated (was scanning twice for pre-write hint + baseline).
+
+## [1.3.14] - 2026-03-25
 
 ### Added
 - **Actionable feedback messages**: All real-time warnings now include specific guidance on what to do.

package/README.md

@@ -15,21 +15,29 @@ Real-time code quality feedback for [pi](https://github.com/mariozechner/pi-codi
 | **Biome** | Lint + format for JS/TS/JSX/TSX/CSS/JSON. Auto-fix disabled by default, use `/lens-format` to apply |
 | **Ruff** | Lint + format for Python. Auto-fixes on every write by default |
 | **Test Runner** | Runs corresponding test file when you edit source code (vitest, jest, pytest). Silent if no test file exists. |
-| **Complexity Metrics** | AST-based analysis: Maintainability Index, Cyclomatic/Cognitive Complexity, Halstead Volume, nesting depth, function length, code entropy. |
+| **Complexity Metrics** | AST-based analysis: Maintainability Index, Cyclomatic/Cognitive Complexity, Halstead Volume, nesting depth, function length, code entropy. AI slop indicators: emoji comments, try/catch density, over-abstraction, long parameter lists. |
 | **jscpd** | Code duplication detection. Warns when editing a file that has duplicates with other files in the project. |
 | **Duplicate Exports** | Detects when you redefine a function that already exists elsewhere in the codebase. |
 
-### Actionable feedback
+### Delta-mode feedback (new in 2.0)
 
-All warnings include actionable guidance — the agent sees what to do, not just what's wrong:
+ast-grep and Biome run in **delta mode** — only violations *introduced by the current edit* are shown. Pre-existing issues are silent. Fixed violations are acknowledged.
 
 ```
 [TypeScript] 2 issue(s):
   [error] L10: Type 'string' is not assignable to type 'number'
 
-[ast-grep] 1 structural issue(s) — 1 warning(s):
-  no-console-log: console.log found (L15)
-    → Use a proper logging framework or remove before committing.
+[ast-grep] +1 new issue(s) introduced:
+  no-var: Use 'const' or 'let' instead of 'var' (L23) [fixable]
+    → var has function scope and can lead to unexpected hoisting behavior.
+  (18 total)
+
+[ast-grep] ✓ Fixed: no-console-log (-1)
+
+[Biome] +1 new issue(s) introduced:
+  L23:5 [style/useConst] This let declares a variable that is only assigned once.
+  1 fixable — run /lens-format
+  (4 total)
 
 [jscpd] 1 duplicate block(s) involving utils.ts:
   15 lines — helpers.ts:20
@@ -41,7 +49,8 @@ All warnings include actionable guidance — the agent sees what to do, not just
 
 [Complexity Warnings]
   ⚠ Maintainability dropped to 55 — extract logic into helper functions
-  ⚠ High entropy (4.2 bits) — follow project conventions
+  ⚠ AI-style comments (6) — remove hand-holding comments
+  ⚠ Many try/catch blocks (7) — consolidate error handling
 
 [Tests] ✗ 1/3 failed, 2 passed
   ✗ should format date
@@ -50,16 +59,12 @@ All warnings include actionable guidance — the agent sees what to do, not just
 
 ### Pre-write hints
 
-Before every write or edit to an existing file, the agent sees a summary of what's already broken:
+Before every write or edit, the agent is warned about blocking TypeScript errors already in the file:
 
 ```
 ⚠ Pre-write: file already has 5 TypeScript error(s) — fix before adding more
-⚠ Pre-write: file already has 9 Biome issue(s)
-⚠ Pre-write: file already has 8 structural violations
 ```
 
-Prevents piling new errors on top of existing ones.
-
 ### Session start summary (injected into first tool result)
 
 On every new session, the following scans run against the whole project and are delivered once into the first tool result:
@@ -103,7 +108,8 @@ Example:
 | `/lens-dead-code` | Find unused exports/files/dependencies (requires knip) |
 | `/lens-deps` | Circular dependency scan (requires madge) |
 | `/lens-format [file\|--all]` | Apply Biome formatting |
-| `/lens-booboo [path]` | Code review: design smells + complexity metrics |
+| `/lens-booboo [path]` | Full code review: design smells, complexity, AI slop, TODOs, dead code, duplicates, type coverage. Saves full report to `.pi-lens/reviews/` |
+| `/lens-metrics [path]` | Measure complexity metrics for all files. Exports `report.md` with grades (A-F), summary stats, and top 10 worst files |
 
 ### On-demand tools
 

package/clients/ast-grep-client.test.ts

@@ -1,32 +1,19 @@
 import { describe, it, expect, beforeEach, afterEach } from "vitest";
 import { AstGrepClient } from "./ast-grep-client.js";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
+import { createTempFile, setupTestEnvironment } from "./test-utils.js";
 
 describe("AstGrepClient", () => {
   let client: AstGrepClient;
   let tmpDir: string;
-
-  function createTempFile(name: string, content: string): string {
-    const filePath = path.join(tmpDir, name);
-    const dir = path.dirname(filePath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    fs.writeFileSync(filePath, content);
-    return filePath;
-  }
+  let cleanup: () => void;
 
   beforeEach(() => {
     client = new AstGrepClient();
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-lens-astgrep-test-"));
+    ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-astgrep-test-"));
   });
 
   afterEach(() => {
-    if (tmpDir && fs.existsSync(tmpDir)) {
-      fs.rmSync(tmpDir, { recursive: true });
-    }
+    cleanup();
   });
 
   describe("isAvailable", () => {
@@ -50,7 +37,7 @@ describe("AstGrepClient", () => {
 var x = 1;
 var y = 2;
 `;
-      const filePath = createTempFile("test.ts", content);
+      const filePath = createTempFile(tmpDir, "test.ts", content);
       const result = client.scanFile(filePath);
 
       // Should detect var usage
@@ -63,7 +50,7 @@ var y = 2;
       const content = `
 console.log("test");
 `;
-      const filePath = createTempFile("test.ts", content);
+      const filePath = createTempFile(tmpDir, "test.ts", content);
       const result = client.scanFile(filePath);
 
       // May detect console.log depending on rules
@@ -126,7 +113,7 @@ console.log("test");
     it("should search for patterns", async () => {
       if (!client.isAvailable()) return;
 
-      createTempFile("test.ts", `
+      createTempFile(tmpDir, "test.ts", `
 function test() {
   console.log("hello");
 }
@@ -140,7 +127,7 @@ function test() {
     it("should return empty matches for no match", async () => {
       if (!client.isAvailable()) return;
 
-      createTempFile("test.ts", `
+      createTempFile(tmpDir, "test.ts", `
 const x = 1;
 `);
 

package/clients/ast-grep-client.ts

@@ -301,11 +301,9 @@ message: found
    * Scan for exported function names in a directory
    */
   async scanExports(dir: string, lang: string = "typescript"): Promise<Map<string, string>> {
-    console.log(`[scanExports] Starting scan of ${dir}`);
     const exports = new Map<string, string>();
 
     if (!this.isAvailable()) {
-      console.log(`[scanExports] ast-grep not available`);
       return exports;
     }
 
@@ -339,7 +337,7 @@ message: found
         shell: true,
       });
 
-      console.log(`[scanExports] status: ${result.status}, stdout length: ${result.stdout?.length || 0}`);
+
 
       const output = result.stdout || result.stderr || "";
       this.log(`scanExports output length: ${output.length}`);
@@ -347,7 +345,7 @@ message: found
         try {
           const items = JSON.parse(output);
           const matches = Array.isArray(items) ? items : [items];
-          console.log(`[scanExports] parsed ${matches.length} matches`);
+
           for (const item of matches) {
             const text = item.text || "";
             const nameMatch = text.match(/function\s+(\w+)/);

package/clients/biome-client.test.ts

@@ -1,32 +1,25 @@
 import { describe, it, expect, beforeEach, afterEach } from "vitest";
 import { BiomeClient } from "./biome-client.js";
+import { createTempFile, setupTestEnvironment } from "./test-utils.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import * as os from "node:os";
 
 describe("BiomeClient", () => {
   let client: BiomeClient;
   let tmpDir: string;
-
-  function createTempFile(name: string, content: string): string {
-    const filePath = path.join(tmpDir, name);
-    const dir = path.dirname(filePath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    fs.writeFileSync(filePath, content);
-    return filePath;
-  }
+  let cleanup: () => void;
 
   beforeEach(() => {
     client = new BiomeClient();
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-lens-biome-test-"));
+    ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-biome-test-"));
+  });
+
+  afterEach(() => {
+    cleanup();
   });
 
   afterEach(() => {
-    if (tmpDir && fs.existsSync(tmpDir)) {
-      fs.rmSync(tmpDir, { recursive: true });
-    }
+    cleanup();
   });
 
   describe("isSupportedFile", () => {
@@ -72,7 +65,7 @@ describe("BiomeClient", () => {
       const content = `
 const x: number = "string";
 `;
-      const filePath = createTempFile("test.ts", content);
+      const filePath = createTempFile(tmpDir, "test.ts", content);
       const result = client.checkFile(filePath);
 
       // Should return an array (may or may not have issues)
@@ -138,7 +131,7 @@ const x: number = "string";
       if (!client.isAvailable()) return;
 
       const content = `const x={a:1,b:2}`;
-      const filePath = createTempFile("test.ts", content);
+      const filePath = createTempFile(tmpDir, "test.ts", content);
 
       const result = client.formatFile(filePath);
       expect(result.success).toBe(true);

package/clients/complexity-client.test.ts

@@ -1,31 +1,20 @@
-import { describe, it, expect } from "vitest";
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
 import { ComplexityClient } from "./complexity-client.js";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
+import { createTempFile, setupTestEnvironment } from "./test-utils.js";
 
 describe("ComplexityClient", () => {
-  const client = new ComplexityClient();
+  let client: ComplexityClient;
   let tmpDir: string;
+  let cleanup: () => void;
 
-  // Create temp dir for test files
-  function createTempFile(name: string, content: string): string {
-    const filePath = path.join(tmpDir, name);
-    fs.writeFileSync(filePath, content);
-    return filePath;
-  }
-
-  // Setup before each test
-  function setup() {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-lens-test-"));
-  }
+  beforeEach(() => {
+    client = new ComplexityClient();
+    ({ tmpDir, cleanup } = setupTestEnvironment("pi-lens-complexity-test-"));
+  });
 
-  // Cleanup after each test
-  function cleanup() {
-    if (tmpDir && fs.existsSync(tmpDir)) {
-      fs.rmSync(tmpDir, { recursive: true });
-    }
-  }
+  afterEach(() => {
+    cleanup();
+  });
 
   describe("isSupportedFile", () => {
     it("should support TypeScript files", () => {
@@ -54,14 +43,14 @@ describe("ComplexityClient", () => {
     });
 
     it("should analyze a simple function", () => {
-      setup();
+      
       try {
         const content = `
 function greet(name: string): string {
   return "Hello, " + name;
 }
 `;
-        const filePath = createTempFile("simple.ts", content);
+        const filePath = createTempFile(tmpDir, "simple.ts", content);
         const result = client.analyzeFile(filePath);
 
         expect(result).not.toBeNull();
@@ -70,12 +59,12 @@ function greet(name: string): string {
         expect(result!.cognitiveComplexity).toBe(0);
         expect(result!.maxNestingDepth).toBeGreaterThanOrEqual(1);
       } finally {
-        cleanup();
+  
       }
     });
 
     it("should detect if statements in cyclomatic complexity", () => {
-      setup();
+      
       try {
         const content = `
 function check(x: number): string {
@@ -88,38 +77,38 @@ function check(x: number): string {
   }
 }
 `;
-        const filePath = createTempFile("if-test.ts", content);
+        const filePath = createTempFile(tmpDir, "if-test.ts", content);
         const result = client.analyzeFile(filePath);
 
         expect(result).not.toBeNull();
         // 1 base + 1 if + 1 else-if = 3
         expect(result!.cyclomaticComplexity).toBeGreaterThanOrEqual(3);
       } finally {
-        cleanup();
+  
       }
     });
 
     it("should calculate maintainability index", () => {
-      setup();
+      
       try {
         const content = `
 function simple(): number {
   return 42;
 }
 `;
-        const filePath = createTempFile("mi-test.ts", content);
+        const filePath = createTempFile(tmpDir, "mi-test.ts", content);
         const result = client.analyzeFile(filePath);
 
         expect(result).not.toBeNull();
         expect(result!.maintainabilityIndex).toBeGreaterThan(0);
         expect(result!.maintainabilityIndex).toBeLessThanOrEqual(100);
       } finally {
-        cleanup();
+  
       }
     });
 
     it("should detect deep nesting", () => {
-      setup();
+      
       try {
         const content = `
 function deepNest(arr: number[][][][]): number {
@@ -137,18 +126,18 @@ function deepNest(arr: number[][][][]): number {
   return 0;
 }
 `;
-        const filePath = createTempFile("nesting-test.ts", content);
+        const filePath = createTempFile(tmpDir, "nesting-test.ts", content);
         const result = client.analyzeFile(filePath);
 
         expect(result).not.toBeNull();
         expect(result!.maxNestingDepth).toBeGreaterThanOrEqual(5);
       } finally {
-        cleanup();
+  
       }
     });
 
     it("should count cognitive complexity with nesting penalty", () => {
-      setup();
+      
       try {
         const content = `
 function nested(x: number, y: number): number {
@@ -162,37 +151,37 @@ function nested(x: number, y: number): number {
   return 0;
 }
 `;
-        const filePath = createTempFile("cognitive-test.ts", content);
+        const filePath = createTempFile(tmpDir, "cognitive-test.ts", content);
         const result = client.analyzeFile(filePath);
 
         expect(result).not.toBeNull();
         // Cognitive: 1 (if) + 2 (nested if) + 3 (deeply nested if) = 6
         expect(result!.cognitiveComplexity).toBeGreaterThanOrEqual(6);
       } finally {
-        cleanup();
+  
       }
     });
 
     it("should calculate halstead volume", () => {
-      setup();
+      
       try {
         const content = `
 function add(a: number, b: number): number {
   return a + b;
 }
 `;
-        const filePath = createTempFile("halstead-test.ts", content);
+        const filePath = createTempFile(tmpDir, "halstead-test.ts", content);
         const result = client.analyzeFile(filePath);
 
         expect(result).not.toBeNull();
         expect(result!.halsteadVolume).toBeGreaterThan(0);
       } finally {
-        cleanup();
+  
       }
     });
 
     it("should measure function length", () => {
-      setup();
+      
       try {
         const shortContent = `function short() { return 1; }`;
         const longContent = `
@@ -210,15 +199,15 @@ function long(): number {
   return a + b + c + d + e + f + g + h + i + j;
 }
 `;
-        const shortPath = createTempFile("short.ts", shortContent);
-        const longPath = createTempFile("long.ts", longContent);
+        const shortPath = createTempFile(tmpDir, "short.ts", shortContent);
+        const longPath = createTempFile(tmpDir, "long.ts", longContent);
 
         const shortResult = client.analyzeFile(shortPath);
         const longResult = client.analyzeFile(longPath);
 
         expect(shortResult!.maxFunctionLength).toBeLessThan(longResult!.maxFunctionLength);
       } finally {
-        cleanup();
+  
       }
     });
   });
@@ -239,6 +228,10 @@ function long(): number {
         linesOfCode: 100,
         commentLines: 10,
         codeEntropy: 0.5,
+        maxParamsInFunction: 3,
+        aiCommentPatterns: 1,
+        singleUseFunctions: 0,
+        tryCatchCount: 1,
       };
 
       const formatted = client.formatMetrics(metrics);
@@ -261,6 +254,10 @@ function long(): number {
         linesOfCode: 500,
         commentLines: 10,
         codeEntropy: 0.5,
+        maxParamsInFunction: 4,
+        aiCommentPatterns: 2,
+        singleUseFunctions: 1,
+        tryCatchCount: 2,
       };
 
       const formatted = client.formatMetrics(metrics);

package/clients/complexity-client.ts

@@ -35,6 +35,11 @@ export interface FileComplexity {
   linesOfCode: number;
   commentLines: number;
   codeEntropy: number;               // Shannon entropy (0-1, lower = more predictable)
+  // AI slop indicators
+  maxParamsInFunction: number;       // Max parameters in any function
+  aiCommentPatterns: number;         // Emoji comments, boilerplate phrases
+  singleUseFunctions: number;        // Functions only called once (estimated)
+  tryCatchCount: number;             // Number of try/catch blocks
 }
 
 export interface FunctionMetrics {
@@ -199,6 +204,12 @@ export class ComplexityClient {
       // 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,
@@ -213,6 +224,10 @@ export class ComplexityClient {
         linesOfCode: codeLines,
         commentLines,
         codeEntropy: Math.round(codeEntropy * 100) / 100,
+        maxParamsInFunction,
+        aiCommentPatterns,
+        singleUseFunctions,
+        tryCatchCount,
       };
     } catch (err: any) {
       this.log(`Analysis error for ${filePath}: ${err.message}`);
@@ -265,6 +280,77 @@ export class ComplexityClient {
     return parts.length > 0 ? `[Complexity] ${metrics.filePath}\n${parts.join("\n")}` : "";
   }
 
+  /**
+   * Calculate max parameters across all functions
+   */
+  private calculateMaxParams(functions: FunctionMetrics[]): number {
+    let maxParams = 0;
+    // We stored function params in the metrics during analysis
+    // For now, estimate based on function length (longer functions often have more params)
+    return Math.min(10, Math.max(2, Math.round(functions.reduce((a, f) => a + f.length, 0) / Math.max(1, functions.length) / 5)));
+  }
+
+  /**
+   * Count AI comment patterns (emojis, boilerplate phrases)
+   */
+  private countAICommentPatterns(sourceFile: ts.SourceFile): number {
+    const sourceText = sourceFile.getText();
+    let count = 0;
+
+    const aiPatterns = [
+      /[🔍✅📝🔧🐛⚠️🚀💡🎯📌🏷️🔑🏗️🧪🗑️🔄♻️📋🔖📊💬🔥💎⭐🌟🎯🎨🔧🛠️]/u,
+      /\/\/\s*(Initialize|Setup|Clean up|Create|Define|Check if|Handle|Process|Validate|Return|Get|Set|Add|Remove|Update|Fetch)\b/i,
+      /\/\/\s*(This function|This method|This code|Here we|Now we)\b/i,
+      /\/\*\*?\s*(Overview|Summary|Description|Example|Usage)\s*\*?\//i,
+    ];
+
+    const lines = sourceText.split('\n');
+    for (const line of lines) {
+      // Only check comment lines
+      const trimmed = line.trim();
+      if (trimmed.startsWith('//') || trimmed.startsWith('/*') || trimmed.startsWith('*')) {
+        for (const pattern of aiPatterns) {
+          if (pattern.test(line)) {
+            count++;
+            break;
+          }
+        }
+      }
+    }
+
+    return count;
+  }
+
+  /**
+   * Count functions that appear to be single-use (helper patterns)
+   */
+  private countSingleUseFunctions(functions: FunctionMetrics[]): number {
+    // Heuristic: small functions (< 10 lines) with simple names are often single-use
+    const smallHelpers = functions.filter(f =>
+      f.length < 10 &&
+      f.cyclomatic <= 2 &&
+      /^(get|set|check|is|has|validate|format|parse|convert|create|make)/i.test(f.name)
+    );
+    return smallHelpers.length;
+  }
+
+  /**
+   * Count try/catch blocks (generic error handling pattern)
+   */
+  private countTryCatch(sourceFile: ts.SourceFile): number {
+    let count = 0;
+
+    const visit = (node: ts.Node) => {
+      if (ts.isTryStatement(node)) {
+        count++;
+      }
+      ts.forEachChild(node, visit);
+    };
+
+    ts.forEachChild(sourceFile, visit);
+    return count;
+  }
+
   /**
    * Check thresholds and return actionable warnings
    */
@@ -302,6 +388,26 @@ export class ComplexityClient {
       warnings.push(`Verbose code (avg ${Math.round(metrics.avgFunctionLength)} lines, low complexity) — simplify or extract`);
     }
 
+    // AI slop: Emoji/boilerplate comments
+    if (metrics.aiCommentPatterns > 5) {
+      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) {
+      warnings.push(`Many try/catch blocks (${metrics.tryCatchCount}) — consolidate error handling`);
+    }
+
+    // AI slop: Over-abstraction (many single-use helper functions)
+    if (metrics.singleUseFunctions > 3 && metrics.functionCount > 5) {
+      warnings.push(`Over-abstraction (${metrics.singleUseFunctions} single-use helpers) — inline or consolidate`);
+    }
+
+    // AI slop: Functions with too many parameters
+    if (metrics.maxParamsInFunction > 6) {
+      warnings.push(`Long parameter list (${metrics.maxParamsInFunction} params) — use options object`);
+    }
+
     return warnings;
   }