pi-lens 1.3.3 → 1.3.4

package/CHANGELOG.md

@@ -5,8 +5,13 @@ All notable changes to pi-lens will be documented in this file.
 ## [1.4.0] - 2026-03-23
 
 ### Added
+- **Test runner feedback**: Runs corresponding test file on every write (vitest, jest, pytest). Silent if no test file exists. Disable with `--no-tests`.
+- **Complexity metrics**: AST-based analysis: Maintainability Index, Cyclomatic/Cognitive Complexity, Halstead Volume, nesting depth, function length.
+- **`/lens-metrics` command**: Full project complexity scan.
 - **Design smell rules**: New `long-method`, `long-parameter-list`, and `large-class` rules for structural quality checks.
 - **`/design-review` command**: Analyze files for design smells. Usage: `/design-review [path]`
+- **Go language support**: New Go client for Go projects.
+- **Rust language support**: New Rust client for Rust projects.
 
 ### Changed
 - **Improved ast-grep tool descriptions**: Better pattern guidance to prevent overly broad searches.

package/README.md

@@ -14,6 +14,8 @@ Real-time code quality feedback for [pi](https://github.com/mariozechner/pi-codi
 | **ast-grep** | 60+ structural rules: `no-var`, `no-eval`, `no-debugger`, `no-as-any`, `prefer-template`, `no-throw-string`, `no-hardcoded-secrets`, `no-return-await`, nested ternaries, strict equality, and more |
 | **Biome** | Lint + format for JS/TS/JSX/TSX/CSS/JSON. Auto-fixes on every write by default |
 | **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. |
 
 ### Pre-write hints
 
@@ -71,6 +73,7 @@ Example:
 | `/check-deps` | Circular dependency scan (requires madge) |
 | `/format [file|--all]` | Apply Biome formatting |
 | `/design-review [path]` | Analyze files for design smells (long methods, large classes, etc.) |
+| `/lens-metrics [path]` | Full project complexity scan (Maintainability Index, Cognitive/Cyclomatic Complexity, Halstead Volume) |
 
 ### On-demand tools
 
@@ -112,6 +115,9 @@ pip install ruff
 | `--no-ruff` | `false` | Disable Ruff |
 | `--no-lsp` | `false` | Disable TypeScript LSP |
 | `--no-madge` | `false` | Disable circular dependency checking |
+| `--no-tests` | `false` | Disable test runner on write |
+| `--no-go` | `false` | Disable Go linting |
+| `--no-rust` | `false` | Disable Rust linting |
 | `--lens-verbose` | `false` | Enable verbose logging |
 
 ---

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

@@ -0,0 +1,152 @@
+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";
+
+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;
+  }
+
+  beforeEach(() => {
+    client = new AstGrepClient();
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-lens-astgrep-test-"));
+  });
+
+  afterEach(() => {
+    if (tmpDir && fs.existsSync(tmpDir)) {
+      fs.rmSync(tmpDir, { recursive: true });
+    }
+  });
+
+  describe("isAvailable", () => {
+    it("should check ast-grep availability", () => {
+      const available = client.isAvailable();
+      expect(typeof available).toBe("boolean");
+    });
+  });
+
+  describe("scanFile", () => {
+    it("should return empty array for non-existent files", () => {
+      if (!client.isAvailable()) return;
+      const result = client.scanFile("/nonexistent/file.ts");
+      expect(result).toEqual([]);
+    });
+
+    it("should detect var usage (no-var rule)", () => {
+      if (!client.isAvailable()) return;
+
+      const content = `
+var x = 1;
+var y = 2;
+`;
+      const filePath = createTempFile("test.ts", content);
+      const result = client.scanFile(filePath);
+
+      // Should detect var usage
+      expect(result.some(d => d.rule === "no-var")).toBe(true);
+    });
+
+    it("should detect console.log usage", () => {
+      if (!client.isAvailable()) return;
+
+      const content = `
+console.log("test");
+`;
+      const filePath = createTempFile("test.ts", content);
+      const result = client.scanFile(filePath);
+
+      // May detect console.log depending on rules
+      expect(Array.isArray(result)).toBe(true);
+    });
+  });
+
+  describe("formatDiagnostics", () => {
+    it("should format diagnostics for display", () => {
+      const diags = [
+        {
+          line: 1,
+          column: 0,
+          endLine: 1,
+          endColumn: 10,
+          severity: "warning" as const,
+          message: "Unexpected var, use let or const instead",
+          rule: "no-var",
+          file: "test.ts",
+        },
+      ];
+
+      const formatted = client.formatDiagnostics(diags);
+      expect(formatted).toContain("ast-grep");
+      expect(formatted).toContain("no-var");
+    });
+
+    it("should categorize by severity", () => {
+      const diags = [
+        {
+          line: 1, column: 0, endLine: 1, endColumn: 10,
+          severity: "warning" as const, message: "Warning", rule: "rule1", file: "test.ts",
+        },
+        {
+          line: 2, column: 0, endLine: 2, endColumn: 10,
+          severity: "error" as const, message: "Error", rule: "rule2", file: "test.ts",
+        },
+      ];
+
+      const formatted = client.formatDiagnostics(diags);
+      expect(formatted).toContain("warning(s)");
+      expect(formatted).toContain("error(s)");
+    });
+
+    it("should show fixable indicator", () => {
+      const diags = [
+        {
+          line: 1, column: 0, endLine: 1, endColumn: 10,
+          severity: "warning" as const, message: "Use const", rule: "prefer-const",
+          file: "test.ts", fix: "const",
+        },
+      ];
+
+      const formatted = client.formatDiagnostics(diags);
+      expect(formatted).toContain("fixable");
+    });
+  });
+
+  describe("search", () => {
+    it("should search for patterns", async () => {
+      if (!client.isAvailable()) return;
+
+      createTempFile("test.ts", `
+function test() {
+  console.log("hello");
+}
+`);
+
+      const result = await client.search("console.log($MSG)", "typescript", [tmpDir]);
+
+      expect(result.matches.length).toBeGreaterThan(0);
+    });
+
+    it("should return empty matches for no match", async () => {
+      if (!client.isAvailable()) return;
+
+      createTempFile("test.ts", `
+const x = 1;
+`);
+
+      const result = await client.search("console.log($MSG)", "typescript", [tmpDir]);
+
+      expect(result.matches.length).toBe(0);
+    });
+  });
+});

package/clients/biome-client.test.ts

@@ -0,0 +1,151 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { BiomeClient } from "./biome-client.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;
+  }
+
+  beforeEach(() => {
+    client = new BiomeClient();
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-lens-biome-test-"));
+  });
+
+  afterEach(() => {
+    if (tmpDir && fs.existsSync(tmpDir)) {
+      fs.rmSync(tmpDir, { recursive: true });
+    }
+  });
+
+  describe("isSupportedFile", () => {
+    it("should support JS/TS files", () => {
+      expect(client.isSupportedFile("test.js")).toBe(true);
+      expect(client.isSupportedFile("test.jsx")).toBe(true);
+      expect(client.isSupportedFile("test.ts")).toBe(true);
+      expect(client.isSupportedFile("test.tsx")).toBe(true);
+      expect(client.isSupportedFile("test.mjs")).toBe(true);
+      expect(client.isSupportedFile("test.cjs")).toBe(true);
+    });
+
+    it("should support CSS and JSON", () => {
+      expect(client.isSupportedFile("style.css")).toBe(true);
+      expect(client.isSupportedFile("config.json")).toBe(true);
+    });
+
+    it("should not support unsupported files", () => {
+      expect(client.isSupportedFile("test.py")).toBe(false);
+      expect(client.isSupportedFile("test.md")).toBe(false);
+      expect(client.isSupportedFile("test.txt")).toBe(false);
+    });
+  });
+
+  describe("isAvailable", () => {
+    it("should check biome availability", () => {
+      const available = client.isAvailable();
+      // Just verify it doesn't throw - actual availability depends on environment
+      expect(typeof available).toBe("boolean");
+    });
+  });
+
+  describe("checkFile", () => {
+    it("should return empty array for non-existent files", () => {
+      if (!client.isAvailable()) return;
+      const result = client.checkFile("/nonexistent/file.ts");
+      expect(result).toEqual([]);
+    });
+
+    it("should return array of diagnostics for TS files", () => {
+      if (!client.isAvailable()) return;
+
+      const content = `
+const x: number = "string";
+`;
+      const filePath = createTempFile("test.ts", content);
+      const result = client.checkFile(filePath);
+
+      // Should return an array (may or may not have issues)
+      expect(Array.isArray(result)).toBe(true);
+    });
+  });
+
+  describe("formatDiagnostics", () => {
+    it("should format diagnostics for display", () => {
+      const diags = [
+        {
+          line: 1,
+          column: 0,
+          endLine: 1,
+          endColumn: 10,
+          severity: "error" as const,
+          message: "Unexpected var",
+          rule: "noVar",
+          category: "lint" as const,
+          fixable: true,
+        },
+      ];
+
+      const formatted = client.formatDiagnostics(diags, "test.ts");
+      expect(formatted).toContain("Biome");
+      expect(formatted).toContain("1 issue");
+      expect(formatted).toContain("noVar");
+    });
+
+    it("should show fixable count", () => {
+      const diags = [
+        {
+          line: 1, column: 0, endLine: 1, endColumn: 10,
+          severity: "error" as const, message: "Error 1", rule: "rule1",
+          category: "lint" as const, fixable: true,
+        },
+        {
+          line: 2, column: 0, endLine: 2, endColumn: 10,
+          severity: "warning" as const, message: "Warning 1", rule: "rule2",
+          category: "lint" as const, fixable: false,
+        },
+      ];
+
+      const formatted = client.formatDiagnostics(diags, "test.ts");
+      expect(formatted).toContain("1 fixable");
+    });
+
+    it("should truncate long diagnostic lists", () => {
+      const diags = Array.from({ length: 20 }, (_, i) => ({
+        line: i + 1, column: 0, endLine: i + 1, endColumn: 10,
+        severity: "warning" as const, message: `Warning ${i}`, rule: `rule${i}`,
+        category: "lint" as const, fixable: false,
+      }));
+
+      const formatted = client.formatDiagnostics(diags, "test.ts");
+      expect(formatted).toContain("...");
+      expect(formatted).toContain("5 more");
+    });
+  });
+
+  describe("formatFile", () => {
+    it("should format a file", () => {
+      if (!client.isAvailable()) return;
+
+      const content = `const x={a:1,b:2}`;
+      const filePath = createTempFile("test.ts", content);
+
+      const result = client.formatFile(filePath);
+      expect(result.success).toBe(true);
+
+      // Check if file was formatted (should have spaces)
+      const formatted = fs.readFileSync(filePath, "utf-8");
+      expect(formatted).toContain(": "); // Should have spaces after colons
+    });
+  });
+});

package/clients/complexity-client.test.ts

@@ -0,0 +1,268 @@
+import { describe, it, expect } 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";
+
+describe("ComplexityClient", () => {
+  const client = new ComplexityClient();
+  let tmpDir: string;
+
+  // 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-"));
+  }
+
+  // Cleanup after each test
+  function cleanup() {
+    if (tmpDir && fs.existsSync(tmpDir)) {
+      fs.rmSync(tmpDir, { recursive: true });
+    }
+  }
+
+  describe("isSupportedFile", () => {
+    it("should support TypeScript files", () => {
+      expect(client.isSupportedFile("test.ts")).toBe(true);
+      expect(client.isSupportedFile("test.tsx")).toBe(true);
+    });
+
+    it("should support JavaScript files", () => {
+      expect(client.isSupportedFile("test.js")).toBe(true);
+      expect(client.isSupportedFile("test.jsx")).toBe(true);
+      expect(client.isSupportedFile("test.mjs")).toBe(true);
+      expect(client.isSupportedFile("test.cjs")).toBe(true);
+    });
+
+    it("should not support non-TS/JS files", () => {
+      expect(client.isSupportedFile("test.py")).toBe(false);
+      expect(client.isSupportedFile("test.json")).toBe(false);
+      expect(client.isSupportedFile("test.md")).toBe(false);
+    });
+  });
+
+  describe("analyzeFile", () => {
+    it("should return null for non-existent files", () => {
+      const result = client.analyzeFile("/nonexistent/file.ts");
+      expect(result).toBeNull();
+    });
+
+    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 result = client.analyzeFile(filePath);
+
+        expect(result).not.toBeNull();
+        expect(result!.functionCount).toBe(1);
+        expect(result!.cyclomaticComplexity).toBe(1);
+        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 {
+  if (x > 0) {
+    return "positive";
+  } else if (x < 0) {
+    return "negative";
+  } else {
+    return "zero";
+  }
+}
+`;
+        const filePath = createTempFile("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 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 {
+  for (let i = 0; i < arr.length; i++) {
+    for (let j = 0; j < arr[i].length; j++) {
+      for (let k = 0; k < arr[i][j].length; k++) {
+        for (let l = 0; l < arr[i][j][k].length; l++) {
+          if (arr[i][j][k][l] > 0) {
+            return arr[i][j][k][l];
+          }
+        }
+      }
+    }
+  }
+  return 0;
+}
+`;
+        const filePath = createTempFile("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 {
+  if (x > 0) {
+    if (y > 0) {
+      if (x > y) {
+        return 1;
+      }
+    }
+  }
+  return 0;
+}
+`;
+        const filePath = createTempFile("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 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 = `
+function long(): number {
+  const a = 1;
+  const b = 2;
+  const c = 3;
+  const d = 4;
+  const e = 5;
+  const f = 6;
+  const g = 7;
+  const h = 8;
+  const i = 9;
+  const j = 10;
+  return a + b + c + d + e + f + g + h + i + j;
+}
+`;
+        const shortPath = createTempFile("short.ts", shortContent);
+        const longPath = createTempFile("long.ts", longContent);
+
+        const shortResult = client.analyzeFile(shortPath);
+        const longResult = client.analyzeFile(longPath);
+
+        expect(shortResult!.maxFunctionLength).toBeLessThan(longResult!.maxFunctionLength);
+      } finally {
+        cleanup();
+      }
+    });
+  });
+
+  describe("formatMetrics", () => {
+    it("should format metrics for display", () => {
+      const metrics = {
+        filePath: "test.ts",
+        maxNestingDepth: 4,
+        avgFunctionLength: 15,
+        maxFunctionLength: 30,
+        functionCount: 3,
+        cyclomaticComplexity: 4,
+        maxCyclomaticComplexity: 8,
+        cognitiveComplexity: 12,
+        halsteadVolume: 200,
+        maintainabilityIndex: 75,
+        linesOfCode: 100,
+        commentLines: 10,
+      };
+
+      const formatted = client.formatMetrics(metrics);
+      expect(formatted).toContain("test.ts");
+      expect(formatted).toContain("75/100");
+    });
+
+    it("should warn about low maintainability", () => {
+      const metrics = {
+        filePath: "bad.ts",
+        maxNestingDepth: 8,
+        avgFunctionLength: 60,
+        maxFunctionLength: 100,
+        functionCount: 5,
+        cyclomaticComplexity: 15,
+        maxCyclomaticComplexity: 25,
+        cognitiveComplexity: 50,
+        halsteadVolume: 800,
+        maintainabilityIndex: 25,
+        linesOfCode: 500,
+        commentLines: 10,
+      };
+
+      const formatted = client.formatMetrics(metrics);
+      expect(formatted).toContain("✗");  // Low MI indicator
+    });
+  });
+});