pi-lens 1.3.7 → 1.3.9

package/clients/complexity-client.test.ts

@@ -238,6 +238,7 @@ function long(): number {
         maintainabilityIndex: 75,
         linesOfCode: 100,
         commentLines: 10,
+        codeEntropy: 0.5,
       };
 
       const formatted = client.formatMetrics(metrics);
@@ -259,6 +260,7 @@ function long(): number {
         maintainabilityIndex: 25,
         linesOfCode: 500,
         commentLines: 10,
+        codeEntropy: 0.5,
       };
 
       const formatted = client.formatMetrics(metrics);

package/clients/complexity-client.ts

@@ -34,6 +34,7 @@ export interface FileComplexity {
   maintainabilityIndex: number;      // 0-100
   linesOfCode: number;
   commentLines: number;
+  codeEntropy: number;               // Shannon entropy (0-1, lower = more predictable)
 }
 
 export interface FunctionMetrics {
@@ -195,6 +196,9 @@ export class ComplexityClient {
         commentLines
       );
 
+      // Code Entropy (Shannon entropy of code tokens)
+      const codeEntropy = this.calculateCodeEntropy(content);
+
       return {
         filePath: path.relative(process.cwd(), absolutePath),
         maxNestingDepth,
@@ -208,6 +212,7 @@ export class ComplexityClient {
         maintainabilityIndex: Math.round(maintainabilityIndex * 10) / 10,
         linesOfCode: codeLines,
         commentLines,
+        codeEntropy: Math.round(codeEntropy * 100) / 100,
       };
     } catch (err: any) {
       this.log(`Analysis error for ${filePath}: ${err.message}`);
@@ -242,6 +247,11 @@ export class ComplexityClient {
       parts.push(`  Max nesting: ${metrics.maxNestingDepth} levels (consider extracting)`);
     }
 
+    // Code entropy (in bits, >3.5 = risky AI-induced complexity)
+    if (metrics.codeEntropy > 3.5) {
+      parts.push(`  Entropy: ${metrics.codeEntropy.toFixed(1)} bits (>3.5 — risky AI-induced complexity)`);
+    }
+
     // Function length
     if (metrics.maxFunctionLength > 50) {
       parts.push(`  Longest function: ${metrics.maxFunctionLength} lines (avg: ${metrics.avgFunctionLength})`);
@@ -491,6 +501,41 @@ export class ComplexityClient {
     return totalOps * Math.log2(uniqueOps);
   }
 
+  /**
+   * Calculate Shannon entropy of code tokens (in bits)
+   * Uses log2 for entropy measured in bits
+   * Threshold: >3.5 bits indicates risky AI-induced complexity
+   */
+  private calculateCodeEntropy(sourceText: string): number {
+    // Tokenize by splitting on whitespace and common delimiters
+    const tokens = sourceText
+      .replace(/\/\/.*/g, "")           // Remove single-line comments
+      .replace(/\/\*[\s\S]*?\*\//g, "") // Remove multi-line comments
+      .replace(/["'`][^"'`]*["'`]/g, "STR") // Normalize strings
+      .replace(/\b\d+(\.\d+)?\b/g, "NUM")   // Normalize numbers
+      .split(/[\s\n\r\t,;:()[\]{}=<>!&|+\-*/%^~?]+/)
+      .filter(t => t.length > 0);
+
+    if (tokens.length === 0) return 0;
+
+    // Count token frequencies
+    const freq = new Map<string, number>();
+    for (const token of tokens) {
+      freq.set(token, (freq.get(token) || 0) + 1);
+    }
+
+    // Calculate Shannon entropy in bits: H = -sum(p * log2(p))
+    let entropy = 0;
+    for (const count of freq.values()) {
+      const p = count / tokens.length;
+      if (p > 0) {
+        entropy -= p * Math.log2(p);
+      }
+    }
+
+    return entropy; // Return in bits, not normalized
+  }
+
   private isKeyword(text: string): boolean {
     const keywords = new Set([
       "if", "else", "for", "while", "do", "switch", "case", "break", "continue",

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-lens",
-	"version": "1.3.7",
+	"version": "1.3.9",
 	"description": "Real-time code feedback for pi — TypeScript LSP, Biome, ast-grep, Ruff, TODO scanner, dead code, duplicate detection, type coverage",
 	"repository": {
 		"type": "git",