pi-lens 1.3.6 → 1.3.8

package/README.md

@@ -73,7 +73,7 @@ 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-review [path]` | Code review: design smells + complexity metrics |
+| `/lens-booboo [path]` | Code review: design smells + complexity metrics |
 
 ### On-demand tools
 

package/clients/ast-grep-client.ts

@@ -200,6 +200,103 @@ export class AstGrepClient {
     return { matches: result.matches, applied: apply, error: result.error };
   }
 
+  /**
+   * Find similar functions by comparing normalized AST structure
+   */
+  async findSimilarFunctions(dir: string, lang: string = "typescript"): Promise<Array<{ pattern: string; functions: Array<{ name: string; file: string; line: number }> }>> {
+    if (!this.isAvailable()) return [];
+
+    const tmpDir = require("node:os").tmpdir();
+    const ts = Date.now();
+    const ruleDir = require("node:path").join(tmpDir, `pi-lens-similar-${ts}`);
+    const rulesSubdir = require("node:path").join(ruleDir, "rules");
+    const ruleFile = require("node:path").join(rulesSubdir, "find-functions.yml");
+    const configFile = require("node:path").join(ruleDir, ".sgconfig.yml");
+
+    require("node:fs").mkdirSync(rulesSubdir, { recursive: true });
+    require("node:fs").writeFileSync(configFile, `ruleDirs:\n  - ./rules\n`);
+    require("node:fs").writeFileSync(ruleFile, `id: find-functions
+language: ${lang}
+rule:
+  kind: function_declaration
+severity: info
+message: found
+`);
+
+    try {
+      const result = spawnSync("npx", [
+        "sg", "scan",
+        "--config", configFile,
+        "--json",
+        dir,
+      ], {
+        encoding: "utf-8",
+        timeout: 30000,
+        shell: true,
+      });
+
+      const output = result.stdout || result.stderr || "";
+      if (!output.trim()) return [];
+
+      const items = JSON.parse(output);
+      const matches = Array.isArray(items) ? items : [items];
+
+      // Normalize each function by removing identifiers
+      const normalized = new Map<string, Array<{ name: string; file: string; line: number }>>();
+
+      for (const item of matches) {
+        const text = item.text || "";
+        const nameMatch = text.match(/function\s+(\w+)/);
+        if (!nameMatch || !nameMatch[1]) continue;
+
+        // Normalize by replacing function name with FN, parameters with P1..Pn, and removing specific values
+        let normalizedText = text
+          .replace(/function\s+\w+/, "function FN")
+          .replace(/\bconst\b|\blet\b|\bvar\b/g, "VAR")
+          .replace(/["'].*?["']/g, "STR")
+          .replace(/`[^`]*`/g, "TMPL")
+          .replace(/\b\d+\b/g, "NUM")
+          .replace(/\btrue\b|\bfalse\b/g, "BOOL")
+          .replace(/\/\/.*/g, "")
+          .replace(/\/\*[\s\S]*?\*\//g, "")
+          .replace(/\s+/g, " ")
+          .trim();
+
+        // Extract just the body structure
+        const bodyMatch = normalizedText.match(/\{(.*)\}/);
+        const body = bodyMatch ? bodyMatch[1].trim() : normalizedText;
+
+        // Use first 200 chars as signature
+        const signature = body.slice(0, 200);
+
+        if (!normalized.has(signature)) {
+          normalized.set(signature, []);
+        }
+
+        const line = item.range?.start?.line || item.labels?.[0]?.range?.start?.line || 0;
+        normalized.get(signature)!.push({
+          name: nameMatch[1],
+          file: item.file,
+          line: line + 1,
+        });
+      }
+
+      // Return groups with more than one function
+      const result_groups: Array<{ pattern: string; functions: Array<{ name: string; file: string; line: number }> }> = [];
+      for (const [pattern, functions] of normalized) {
+        if (functions.length > 1) {
+          result_groups.push({ pattern, functions });
+        }
+      }
+
+      return result_groups;
+    } catch {
+      return [];
+    } finally {
+      try { require("node:fs").rmSync(ruleDir, { recursive: true, force: true }); } catch {}
+    }
+  }
+
   /**
    * Scan for exported function names in a directory
    */

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 * 1000) / 1000,
       };
     } catch (err: any) {
       this.log(`Analysis error for ${filePath}: ${err.message}`);
@@ -242,6 +247,13 @@ export class ComplexityClient {
       parts.push(`  Max nesting: ${metrics.maxNestingDepth} levels (consider extracting)`);
     }
 
+    // Code entropy (0-1, lower = more predictable)
+    if (metrics.codeEntropy > 0.8) {
+      parts.push(`  Entropy: ${metrics.codeEntropy} (high — code may be unpredictable/AI-generated)`);
+    } else if (metrics.codeEntropy < 0.3) {
+      parts.push(`  Entropy: ${metrics.codeEntropy} (low — repetitive patterns detected)`);
+    }
+
     // Function length
     if (metrics.maxFunctionLength > 50) {
       parts.push(`  Longest function: ${metrics.maxFunctionLength} lines (avg: ${metrics.avgFunctionLength})`);
@@ -491,6 +503,45 @@ export class ComplexityClient {
     return totalOps * Math.log2(uniqueOps);
   }
 
+  /**
+   * Calculate Shannon entropy of code tokens
+   * Measures predictability/uniformity of code
+   * 0 = completely uniform, 1 = maximum entropy
+   */
+  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: 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);
+      }
+    }
+
+    // Normalize to 0-1 range
+    const maxEntropy = Math.log2(freq.size);
+    if (maxEntropy === 0) return 0;
+
+    return Math.min(1, entropy / maxEntropy);
+  }
+
   private isKeyword(text: string): boolean {
     const keywords = new Set([
       "if", "else", "for", "while", "do", "switch", "case", "break", "continue",

package/index.ts

@@ -215,9 +215,9 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
-	pi.registerCommand("lens-review", {
+	pi.registerCommand("lens-booboo", {
 		description:
-			"Code review: design smells + complexity metrics. Usage: /lens-review [path]",
+			"Code review: design smells + complexity metrics. Usage: /lens-booboo [path]",
 		handler: async (args, ctx) => {
 			const targetPath = args.trim() || ctx.cwd || process.cwd();
 			ctx.ui.notify("🔍 Running code review...", "info");
@@ -286,7 +286,25 @@ export default function (pi: ExtensionAPI) {
 				}
 			}
 
-			// Part 2: Complexity metrics
+			// Part 2: Similar functions (advanced duplicate detection)
+			if (astGrepClient.isAvailable()) {
+				const similarGroups = await astGrepClient.findSimilarFunctions(targetPath, "typescript");
+				if (similarGroups.length > 0) {
+					let report = `[Similar Functions] ${similarGroups.length} group(s) of structurally similar functions:\n`;
+					for (const group of similarGroups.slice(0, 5)) {
+						report += `  Pattern: ${group.functions.map(f => f.name).join(", ")}\n`;
+						for (const fn of group.functions) {
+							report += `    ${fn.name} (${path.basename(fn.file)}:${fn.line})\n`;
+						}
+					}
+					if (similarGroups.length > 5) {
+						report += `  ... and ${similarGroups.length - 5} more groups\n`;
+					}
+					parts.push(report);
+				}
+			}
+
+			// Part 3: Complexity metrics
 			const results: import("./clients/complexity-client.js").FileComplexity[] = [];
 
 			const scanDir = (dir: string) => {

package/package.json

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